@planu/cli 4.1.0 → 4.1.2

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

@@ -1,1681 +0,0 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-/* 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-platform.ts — Group F: Platform tools (inline registry)
-//
-// Phase 3 (refactor/registry-phase3): inlines register-*.ts files for:
-//   migration, apply-migration-cleanup, stack, template, search, import,
-//   hooks, filesystem-hooks, dep-audit, changelog, event, feedback, comments, memory,
-//   infrastructure, global-rules, plan-mode, quality-gates, verifier (empty shim), context-profile
-import { z } from 'zod';
-import { safeLicensed, safeTracked } from '../safe-handler.js';
-import { projectIdSchema, withProject } from '../tool-registry-helpers.js';
-import { makeDeprecationStub } from './deprecated-stubs.js';
-import { registerFromEntries } from '../tool-entry.js';
-// ── SPEC-966: OpenCode Host Adapter ────────────────────────────────────────────
-import { handleOpenCodeHostAdapter } from '../opencode-host-adapter.js';
-// ── Migration (register-migration-tools.ts) ───────────────────────────────────
-import { t } from '../../i18n/index.js';
-import { handleMigrateTech } from '../migrate-tech.js';
-// ── Apply Migration Cleanup (register-apply-migration-cleanup.ts) ─────────────
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { checkCriteriaQuality } from '../../engine/criteria-quality-checker.js';
-// ── Stack (register-stack-tools.ts) ──────────────────────────────────────────
-import { handleAuditStack } from '../audit-stack.js';
-import { handlePlanUpgrade } from '../plan-upgrade.js';
-import { handleDetectDeprecations } from '../detect-deprecations.js';
-// ── Template (register-template-tools.ts) ────────────────────────────────────
-import { handleListTemplates, handleApplyTemplate } from '../spec-templates.js';
-// ── Search (register-search-tools.ts) ────────────────────────────────────────
-import { handleSemanticSearch } from '../semantic-search-handler.js';
-// ── Import (register-import-tools.ts) ────────────────────────────────────────
-import { handleImportSpec, handleBulkImport } from '../import-spec-handler.js';
-// ── Hooks (register-hooks-tools.ts) ──────────────────────────────────────────
-import { handleManageHooks } from '../manage-hooks.js';
-import { handleStartHooks, handleStopHooks, handleHookStatus, handleConfigureHooks, } from '../start-hooks.js';
-// ── Filesystem Hooks (register-filesystem-hooks-tools.ts) ────────────────────
-import { handleConfigureFilesystemHooks } from '../filesystem-hooks-handler.js';
-// ── Dep Audit (register-dep-audit-tools.ts) ───────────────────────────────────
-import { auditDeps } from '../../engine/dep-auditor/index.js';
-import { handleDependencyHealth } from '../dependency-health.js';
-// ── CVE Refresher (SPEC-773) ─────────────────────────────────────────────────
-import { isCveDatabaseStale, refreshCveDatabase } from '../../engine/security/cve-refresher.js';
-// ── Changelog (register-changelog-tools.ts) ───────────────────────────────────
-import { handleSpecHistory } from '../spec-history.js';
-// ── Event (register-event-tools.ts) ───────────────────────────────────────────
-import { handleEventContracts } from '../event-contracts.js';
-// ── Feedback (register-feedback-tools.ts) ────────────────────────────────────
-import { handleSubmitFeedback, handleTriageFeedback, handleResolveFeedback, } from '../feedback-handler.js';
-// ── Comments (register-comments-tools.ts) ────────────────────────────────────
-import { handleAddComment, handleListComments, handleResolveComment, handleReplyComment, } from '../comments-handler.js';
-// ── Memory (register-memory-tools.ts) ────────────────────────────────────────
-import { handleLogDecision } from '../log-decision.js';
-import { handleRealityCheck } from '../reality-check.js';
-// ── Infrastructure (register-infrastructure-tools.ts) ────────────────────────
-import { handleGenerateInfrastructure } from '../generate-infrastructure.js';
-// ── Global Rules (register-global-rules-tools.ts) ────────────────────────────
-import { handleManageGlobalRules, handleGlobalRulesStatus, } from '../global-rules-handler.js';
-// ── Plan Mode (register-plan-mode-tools.ts) ───────────────────────────────────
-import { handlePlanMode } from '../plan-mode-handler.js';
-// ── Quality Gates (register-quality-gates.ts) ────────────────────────────────
-import { handleInjectQualityGates } from '../inject-quality-gates-handler.js';
-// ── Context Profile (register-context-profile.ts) ────────────────────────────
-import { setActiveProfile, getActiveProfile } from '../../storage/context-profile-store.js';
-import { getProfile, getAllProfiles } from '../../engine/context-profile/profile-catalog.js';
-// ── Dep Audit — report formatting helpers ─────────────────────────────────────
-function vulnLine(vuln) {
-    const fix = vuln.fixedIn ? ` — fixed in ${vuln.fixedIn}` : ' — no fix available';
-    return `  - [${vuln.severity.toUpperCase()}] ${vuln.cveId}: ${vuln.description}${fix}`;
-}
-function entryLines(entry) {
-    const lines = [`- **${entry.name}** @ ${entry.currentVersion}`];
-    for (const v of entry.vulns) {
-        lines.push(vulnLine(v));
-    }
-    if (entry.license.compatibility === 'critical') {
-        lines.push(`  - [LICENSE] ${entry.license.reason}`);
-    }
-    if (entry.abandoned.isAbandoned) {
-        lines.push(`  - [ABANDONED] ${entry.abandoned.reason}`);
-        if (entry.abandoned.suggestedAlternative) {
-            lines.push(`    Alternative: ${entry.abandoned.suggestedAlternative}`);
-        }
-    }
-    return lines;
-}
-function criticalVulnCves(report) {
-    const cves = [];
-    for (const entry of report.critical) {
-        for (const v of entry.vulns) {
-            if (v.severity === 'critical') {
-                cves.push(`${v.cveId} (${entry.name})`);
-            }
-        }
-    }
-    return cves;
-}
-function buildFullReport(report) {
-    const lines = [
-        '## Security Scan Report',
-        '',
-        `**Ecosystem**: ${report.ecosystem}`,
-        `**Dependencies scanned**: ${report.totalDeps}`,
-        `**Summary**: ${report.summary}`,
-        '',
-    ];
-    if (report.critical.length > 0) {
-        lines.push('### Critical Issues', '');
-        for (const entry of report.critical) {
-            lines.push(...entryLines(entry));
-        }
-        lines.push('');
-    }
-    if (report.warnings.length > 0) {
-        lines.push('### Warnings (high/medium severity)', '');
-        for (const entry of report.warnings) {
-            lines.push(...entryLines(entry));
-        }
-        lines.push('');
-    }
-    if (report.duplicates.length > 0) {
-        lines.push('### Duplicate Dependency Groups', '');
-        for (const dup of report.duplicates) {
-            lines.push(`- [${dup.category}] ${dup.packages.join(', ')} — ${dup.recommendation}`);
-        }
-        lines.push('');
-    }
-    if (report.critical.length === 0 && report.warnings.length === 0) {
-        lines.push('No vulnerabilities or license conflicts detected.', '');
-    }
-    return lines.join('\n');
-}
-function buildFreeReport(report) {
-    const criticalEntries = report.critical.filter((e) => e.vulns.some((v) => v.severity === 'critical'));
-    const lines = [
-        '## Security Scan Report (free tier — npm critical CVEs only)',
-        '',
-        `**Ecosystem**: ${report.ecosystem}`,
-        `**Dependencies scanned**: ${report.totalDeps}`,
-        '',
-    ];
-    if (criticalEntries.length === 0) {
-        lines.push('No critical CVEs detected in npm dependencies.');
-    }
-    else {
-        lines.push('### Critical CVEs Detected', '');
-        for (const entry of criticalEntries) {
-            for (const v of entry.vulns) {
-                if (v.severity === 'critical') {
-                    lines.push(vulnLine(v).replace(/^ {2}/, `- ${entry.name}@${entry.currentVersion} `));
-                }
-            }
-        }
-        lines.push('');
-        lines.push('> Upgrade to Pro to see high/medium vulnerabilities, license conflicts, and abandoned packages.');
-    }
-    return lines.join('\n');
-}
-// ── Apply Migration Cleanup — helpers ─────────────────────────────────────────
-async function findSpecPath(projectPath, specId) {
-    const { readdir, stat } = await import('node:fs/promises');
-    const specsDir = join(projectPath, 'planu/specs');
-    let entries;
-    try {
-        entries = await readdir(specsDir);
-    }
-    catch {
-        return null;
-    }
-    for (const entry of entries) {
-        if (!entry.startsWith(specId)) {
-            continue;
-        }
-        const specDir = join(specsDir, entry);
-        try {
-            const info = await stat(specDir);
-            if (info.isDirectory()) {
-                return join(specDir, 'spec.md');
-            }
-        }
-        catch {
-            // skip
-        }
-    }
-    return null;
-}
-function replaceCriterionInFrontmatter(content, escapedOld, escapedNew) {
-    if (!content.startsWith('---\n')) {
-        return null;
-    }
-    const closingIdx = content.indexOf('\n---', 4);
-    if (closingIdx < 0) {
-        return null;
-    }
-    const frontmatter = content.slice(4, closingIdx);
-    const afterFm = content.slice(closingIdx);
-    const target = `  - text: "${escapedOld}"`;
-    if (!frontmatter.includes(target)) {
-        return null;
-    }
-    const updatedFm = frontmatter.replace(target, `  - text: "${escapedNew}"`);
-    return `---\n${updatedFm}${afterFm}`;
-}
-// ── Context Profile ───────────────────────────────────────────────────────────
-const AVAILABLE_PHASES = ['brainstorm', 'plan', 'implement', 'review', 'release'];
-const projectPathField = z
-    .string()
-    .min(1)
-    .max(4096)
-    .describe('Absolute path to the project root directory.');
-const phaseField = z
-    .enum(['brainstorm', 'plan', 'implement', 'review', 'release'])
-    .describe('Work phase to activate: ' +
-    'brainstorm=explore ideas, ' +
-    'plan=design specs, ' +
-    'implement=build features, ' +
-    'review=validate quality, ' +
-    'release=publish');
-// ── Migration enum ────────────────────────────────────────────────────────────
-const MigrateTechActionEnum = z.enum([
-    'analyze',
-    'map',
-    'plan',
-    'strategy',
-    'validate',
-    'analyze-db',
-    'map-db',
-    'plan-db',
-    'analyze-services',
-    'map-services',
-    'plan-services',
-    'validate-service',
-    'rollback-plan',
-    'checkpoint',
-    'rollback',
-    'feature-flags',
-    'status',
-    'webpack-to-vite',
-    'vite6-to-vite7',
-    'detect-pending',
-]);
-// ── Template constants ────────────────────────────────────────────────────────
-const TEMPLATE_CATEGORIES = [
-    'auth',
-    'crud',
-    'api',
-    'ui',
-    'infra',
-    'testing',
-    'integration',
-    'data',
-    'security',
-    'performance',
-    'industry',
-];
-const COMPLEXITY_SCORES = ['S', 'M', 'L', 'XL'];
-// eslint-disable-next-line max-lines-per-function -- registration catalog: one block per tool. ~40 tools from 20 register-*.ts files.
-export function registerPlatformGroupTools(s) {
-    // ── Migration ───────────────────────────────────────────────────────────────
-    s.registerTool('migrate_tech', {
-        description: t('tools.migrate_tech.description'),
-        annotations: { readOnlyHint: false },
-        inputSchema: {
-            action: MigrateTechActionEnum.describe('Migration action: analyze | map | plan | strategy | validate | analyze-db | map-db | plan-db | analyze-services | map-services | plan-services | validate-service | rollback-plan | checkpoint | rollback | feature-flags | status | webpack-to-vite | vite6-to-vite7 | detect-pending'),
-            ...projectIdSchema,
-            sourceStack: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Source technology stack (e.g. "java-spring", "php-laravel", "express") — required for map/plan/strategy'),
-            targetStack: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Target technology stack (e.g. "go", "node-typescript", "fastify") — required for map/plan/strategy'),
-            component: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Component name to validate (required for validate action)'),
-            sourceDbEngine: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Source database engine (e.g. "postgresql", "mysql", "mongodb") — required for analyze-db/map-db/plan-db'),
-            targetDbEngine: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Target database engine — required for map-db/plan-db'),
-            existingAnalysisId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('ID of a previous analyze result to reuse for plan/strategy actions'),
-        },
-    }, safeLicensed('migrate_tech', withProject((args) => handleMigrateTech(args))));
-    // ── Apply Migration Cleanup ─────────────────────────────────────────────────
-    s.registerTool('apply_migration_cleanup', {
-        description: 'Apply rewritten acceptance criteria to spec files. ' +
-            'Each rewritten criterion must score >= 80 via checkCriteriaQuality (GIVEN/WHEN/THEN + concrete value). ' +
-            'Criteria scoring < 80 are skipped and returned in the skipped array. ' +
-            'Call this after list_specs returns migrationIssues and the user approves rewriting.',
-        annotations: { title: 'Apply Migration Cleanup', destructiveHint: true },
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root where planu/ directory lives.'),
-            rewrittenCriteria: z
-                .array(z.object({
-                specId: z.string().min(1).max(500).describe('Spec ID (e.g. SPEC-042).'),
-                oldText: z.string().min(1).max(2000).describe('Exact criterion text to replace.'),
-                newText: z
-                    .string()
-                    .min(1)
-                    .max(2000)
-                    .describe('Replacement criterion in GIVEN/WHEN/THEN format with concrete values.'),
-            }))
-                .min(1)
-                .max(200)
-                .describe('Array of criteria rewrites. Each entry: { specId, oldText, newText }. ' +
-                'newText must use GIVEN/WHEN/THEN with a concrete value to score >= 80.'),
-        },
-    }, safeTracked('apply_migration_cleanup', async (args) => {
-        const { projectPath, rewrittenCriteria } = args;
-        let criteriaUpdated = 0;
-        const skipped = [];
-        for (const { specId, oldText, newText } of rewrittenCriteria) {
-            const quality = checkCriteriaQuality(newText);
-            if (quality.score < 80) {
-                skipped.push({
-                    specId,
-                    criterionText: newText,
-                    reason: `Score ${String(quality.score)}/100 — ${quality.reason}`,
-                });
-                continue;
-            }
-            const specPath = await findSpecPath(projectPath, specId);
-            if (!specPath) {
-                skipped.push({
-                    specId,
-                    criterionText: oldText,
-                    reason: 'spec.md not found for this specId',
-                });
-                continue;
-            }
-            let content;
-            try {
-                content = await readFile(specPath, 'utf-8');
-            }
-            catch {
-                skipped.push({ specId, criterionText: oldText, reason: 'Could not read spec.md' });
-                continue;
-            }
-            const escapedOld = oldText.replace(/"/g, '\\"');
-            const escapedNew = newText.replace(/"/g, '\\"');
-            if (!content.includes(`"${escapedOld}"`)) {
-                skipped.push({
-                    specId,
-                    criterionText: oldText,
-                    reason: 'Criterion text not found in spec.md (already updated or text mismatch)',
-                });
-                continue;
-            }
-            const updatedContent = replaceCriterionInFrontmatter(content, escapedOld, escapedNew);
-            if (updatedContent === null) {
-                skipped.push({
-                    specId,
-                    criterionText: oldText,
-                    reason: 'Could not locate criterion in YAML frontmatter',
-                });
-                continue;
-            }
-            try {
-                await writeFile(specPath, updatedContent, 'utf-8');
-                criteriaUpdated++;
-            }
-            catch {
-                skipped.push({ specId, criterionText: oldText, reason: 'Could not write spec.md' });
-            }
-        }
-        const summary = [
-            `✓ ${String(criteriaUpdated)} criteria updated`,
-            skipped.length > 0 ? `✗ ${String(skipped.length)} skipped` : '',
-        ]
-            .filter(Boolean)
-            .join(' · ');
-        return {
-            content: [{ type: 'text', text: summary }],
-            structuredContent: { criteriaUpdated, skipped },
-        };
-    }));
-    // ── Stack ───────────────────────────────────────────────────────────────────
-    s.registerTool('audit_stack', {
-        description: 'Audit all project dependencies, classify as up_to_date/outdated/vulnerable/unmaintained, and generate a StackHealthScore (0-100).',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            ...projectIdSchema,
-            format: z
-                .enum(['summary', 'json'])
-                .optional()
-                .describe('Output format: summary (default) or json'),
-            since: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('ISO timestamp — show only changes since this date'),
-            failOn: z
-                .enum(['none', 'warning', 'critical'])
-                .optional()
-                .describe('Set isError=true if score drops below threshold (for CI usage)'),
-            ci: z.boolean().optional().describe('CI mode — exit with error on critical findings'),
-        },
-    }, safeLicensed('audit_stack', withProject((args) => handleAuditStack(args))));
-    s.registerTool('plan_upgrade', {
-        description: 'Generate a migration plan for upgrading a specific package, including breaking changes, estimated effort, and rollback procedure.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            ...projectIdSchema,
-            packageName: z
-                .string()
-                .max(500)
-                .describe('Name of the package to upgrade (e.g. "express")'),
-            fromVersion: z.string().max(500).describe('Current installed version'),
-            targetVersion: z.string().max(500).describe('Target version to upgrade to'),
-            changelogText: z
-                .string()
-                .max(1_000_000)
-                .optional()
-                .describe('Optional CHANGELOG.md content for breaking-change analysis'),
-            format: z
-                .enum(['summary', 'json'])
-                .optional()
-                .describe('Output format: summary (default) or json'),
-        },
-    }, safeLicensed('plan_upgrade', withProject((args) => handlePlanUpgrade(args))));
-    s.registerTool('detect_deprecations', {
-        description: 'Scan project source files for deprecated API patterns (pattern-based, no network). Returns a deprecation report with tech-debt estimate.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            ...projectIdSchema,
-            ecosystem: z
-                .enum(['nodejs', 'python', 'browser', 'go', 'java', 'rust', 'dotnet'])
-                .optional()
-                .describe('Override ecosystem detection. If omitted, auto-detected from go.mod, Cargo.toml, pom.xml, build.gradle, .csproj, package.json, etc.'),
-            format: z
-                .enum(['summary', 'json'])
-                .optional()
-                .describe('Output format: summary (default) or json'),
-        },
-    }, safeLicensed('detect_deprecations', withProject((args) => handleDetectDeprecations(args))));
-    // ── Templates ───────────────────────────────────────────────────────────────
-    s.registerTool('list_templates', {
-        description: 'Browse the built-in and custom spec template catalog. Returns available templates with descriptions, ' +
-            'categories, tags, complexity scores, and required variables. ' +
-            'Custom templates in data/global/spec-templates/custom/ are included automatically. ' +
-            'Use apply_template to create a spec from a template.',
-        inputSchema: {
-            category: z
-                .enum(TEMPLATE_CATEGORIES)
-                .optional()
-                .describe('Filter templates by category. Type: auth | crud | api | ui | infra | testing | integration | data | security | performance | industry'),
-            search: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Full-text search across template names, descriptions, and tags (case-insensitive)'),
-            complexityScore: z
-                .enum(COMPLEXITY_SCORES)
-                .optional()
-                .describe('Filter by complexity score. Type: S (<16h) | M (16-40h) | L (40-80h) | XL (>80h)'),
-        },
-        annotations: { title: 'List Spec Templates', readOnlyHint: true },
-    }, safeTracked('list_templates', async (args) => handleListTemplates(args)));
-    s.registerTool('apply_template', {
-        description: 'Create a unified spec.md from a spec template. ' +
-            'Templates are language-agnostic and cover common feature patterns (auth, CRUD, API, etc.) and industry verticals (fintech, healthtech, e-commerce, SaaS). ' +
-            'Use list_templates first to discover available templates and their required variables. ' +
-            'Supports partial criteria selection via includeCriteria parameter.',
-        inputSchema: {
-            templateId: z
-                .string()
-                .max(500)
-                .describe('ID of the template to apply (e.g. "auth-jwt", "fintech-kyc"). Use list_templates to get valid IDs.'),
-            projectPath: z
-                .string()
-                .max(4096)
-                .describe('Absolute path to the project root where specs will be created'),
-            variables: z
-                .array(z.object({
-                key: z
-                    .string()
-                    .max(500)
-                    .describe('Variable key as defined in the template (e.g. "EntityName")'),
-                value: z
-                    .string()
-                    .max(10_000)
-                    .describe('Value to substitute for this variable (e.g. "Product")'),
-            }))
-                .max(1000)
-                .describe('Template variable substitutions. Use list_templates to see required variables for each template.'),
-            feature: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Feature group tag (e.g. "Authentication", "Products"). Added to tags for categorization. Flat structure — no subdirectories created.'),
-            outputDir: z
-                .string()
-                .max(4096)
-                .optional()
-                .describe('Custom absolute path for the output directory. Overrides the default planu/specs/{feature}/{template-id}/ layout.'),
-            includeCriteria: z
-                .array(z.string().max(500))
-                .max(1000)
-                .optional()
-                .describe('List of criteria IDs to include (e.g. ["AC-1", "AC-3"]). Omit to include all criteria. Required criteria are always included even if omitted from this list.'),
-        },
-        annotations: { title: 'Apply Spec Template', destructiveHint: false },
-    }, safeLicensed('apply_template', async (args) => handleApplyTemplate(args)));
-    // ── Search ──────────────────────────────────────────────────────────────────
-    s.registerTool('semantic_search', {
-        description: 'Search your project knowledge (specs, patterns, decisions, learned knowledge) by meaning — ' +
-            'not just by exact text. Uses TF-IDF embeddings to find semantically similar documents. ' +
-            'Requires init_project first.',
-        inputSchema: {
-            ...projectIdSchema,
-            query: z.string().max(10_000).describe('Natural language search query'),
-            scope: z
-                .enum(['spec', 'pattern', 'knowledge', 'decision', 'all'])
-                .default('all')
-                .describe('Scope: spec | pattern | knowledge | decision | all'),
-            topK: z.number().default(5).describe('Maximum results to return (default 5)'),
-            threshold: z
-                .number()
-                .default(0.3)
-                .describe('Minimum similarity threshold 0-1 (default 0.3)'),
-        },
-        annotations: { title: 'Semantic Search', readOnlyHint: true },
-    }, safeLicensed('semantic_search', withProject((args) => handleSemanticSearch(args))));
-    // ── Import ──────────────────────────────────────────────────────────────────
-    const ImportSourceEnum = z.enum(['markdown', 'csv']).describe('Source format: markdown | csv');
-    s.registerTool('import_spec', {
-        description: 'Import a spec from an external source (Jira, Linear, Markdown, or CSV) into Planu. ' +
-            'Creates a new spec with the imported content. ' +
-            'Use bulk_import to import multiple specs at once.',
-        inputSchema: {
-            source: ImportSourceEnum,
-            filePath: z
-                .string()
-                .max(4096)
-                .optional()
-                .describe('Absolute path to the source file. Required if content is not provided.'),
-            content: z
-                .string()
-                .max(100_000)
-                .optional()
-                .describe('Inline content string. For jira/linear: JSON string of the issue. For markdown: markdown text. For csv: CSV text.'),
-            projectPath: z.string().max(4096).describe('Absolute path to the target project root'),
-            overwrite: z
-                .boolean()
-                .optional()
-                .describe('Overwrite an existing spec with the same title (default: false). When false, a warning is returned instead of creating a duplicate.'),
-        },
-    }, safeTracked('import_spec', async (args) => handleImportSpec(args)));
-    s.registerTool('bulk_import', {
-        description: 'Bulk import multiple specs from a CSV file or a JSON array of Jira/Linear issues. ' +
-            'Each row in CSV or each item in the JSON array becomes one spec. ' +
-            'Returns a summary with total, succeeded, failed counts and per-spec results.',
-        inputSchema: {
-            source: ImportSourceEnum,
-            filePath: z
-                .string()
-                .max(4096)
-                .optional()
-                .describe('Absolute path to the source file (CSV or JSON array file).'),
-            content: z
-                .string()
-                .max(500_000)
-                .optional()
-                .describe('Inline content string. For csv: CSV with header row. For jira/linear: JSON array of issues.'),
-            projectPath: z.string().max(4096).describe('Absolute path to the target project root'),
-            overwrite: z
-                .boolean()
-                .optional()
-                .describe('Overwrite existing specs with same title (default: false).'),
-        },
-    }, safeTracked('bulk_import', async (args) => handleBulkImport(args)));
-    // ── Hooks ───────────────────────────────────────────────────────────────────
-    s.registerTool('start_hooks', {
-        description: 'Start the file watcher and hook engine for a project. ' +
-            'Idempotent — if already running, returns current status. ' +
-            'Watches for file changes and dispatches to registered hook handlers.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .max(1000)
-                .describe('Absolute path to the project root directory to watch'),
-            hooks: z
-                .array(z.string().max(100))
-                .optional()
-                .describe('Hook types to enable. Valid values: on-save | on-create | on-delete | on-test-pass | on-commit. ' +
-                'Defaults to [on-save, on-create, on-delete]'),
-        },
-        annotations: { title: 'Start Hook Engine', readOnlyHint: false },
-    }, safeLicensed('start_hooks', async (args) => handleStartHooks(args)));
-    s.registerTool('stop_hooks', {
-        description: 'Stop the file watcher and hook engine. Cleans up all resources including ' +
-            'watchers, timers, and event listeners.',
-        inputSchema: {
-            reason: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Optional reason for stopping the hook engine'),
-        },
-        annotations: { title: 'Stop Hook Engine', readOnlyHint: false },
-    }, safeLicensed('stop_hooks', async (args) => handleStopHooks(args)));
-    s.registerTool('hook_status', {
-        description: 'Get the current status of the hook engine including running state, ' +
-            'active hooks, pending events, telemetry (execution count, avg latency, error rate), ' +
-            'and event history count.',
-        inputSchema: {},
-        annotations: { title: 'Hook Engine Status', readOnlyHint: true },
-    }, safeLicensed('hook_status', async () => handleHookStatus()));
-    s.registerTool('configure_hooks', {
-        description: 'View or update hook engine configuration at runtime. ' +
-            'If the engine is running, reloads config from .planu/hooks.json. ' +
-            'If not running, shows current config from disk.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(1000)
-                .describe('Absolute path to the project root directory'),
-            enabled: z.boolean().optional().describe('Master switch for all hooks (true = enabled)'),
-            debounceMs: z
-                .number()
-                .min(50)
-                .max(10000)
-                .optional()
-                .describe('Debounce window in milliseconds (50-10000, default: 300)'),
-            rateLimitPerFileMs: z
-                .number()
-                .min(1000)
-                .max(60000)
-                .optional()
-                .describe('Rate limit per file in milliseconds (1000-60000, default: 5000)'),
-            hooks: z
-                .record(z.string().max(100), z.object({
-                enabled: z.boolean().optional().describe('Whether this hook type is enabled'),
-                include: z.array(z.string().max(500)).optional().describe('Glob patterns to include'),
-                exclude: z.array(z.string().max(500)).optional().describe('Glob patterns to exclude'),
-            }))
-                .optional()
-                .describe('Per-hook-type configuration overrides'),
-            template: z
-                .enum([
-                'notification-macos',
-                'notification-linux',
-                'notification-windows',
-                'notification-desktop',
-                'instructions-loaded-debug',
-                'permission-auto-approve-readonly',
-            ])
-                .optional()
-                .describe('SPEC-258 — Apply a Claude Code hook template. ' +
-                'Valid values: notification-macos | notification-linux | notification-windows | ' +
-                'notification-desktop | instructions-loaded-debug | permission-auto-approve-readonly. ' +
-                'Generates the hook config and merges it into .claude/settings.json.'),
-            notificationMatcher: z
-                .enum(['permission_prompt', 'idle_prompt', 'auth_success', 'elicitation_dialog', ''])
-                .optional()
-                .describe('SPEC-258 — Matcher for notification templates. ' +
-                'Valid values: permission_prompt | idle_prompt | auth_success | elicitation_dialog | "" (all events). ' +
-                'Only used when template is a notification-* variant.'),
-            action: z
-                .enum(['enable-plan-mode-integration'])
-                .optional()
-                .describe('SPEC-262 — Special configure action. ' +
-                'Valid values: enable-plan-mode-integration. ' +
-                'Creates .claude/hooks/planu-pre-plan.sh and .claude/hooks/planu-post-plan.sh and ' +
-                'registers PreToolUse/PostToolUse entries in .claude/settings.json.'),
-        },
-        annotations: { title: 'Configure Hooks', readOnlyHint: false },
-    }, safeLicensed('configure_hooks', async (args) => handleConfigureHooks(args)));
-    s.registerTool('manage_hooks', {
-        description: 'Create, list, delete, enable/disable, and install templates for agent hooks. ' +
-            'Hooks automate actions when Planu events fire (spec created, status change, drift detected, commit). ' +
-            'Use dry_run to preview which hooks would fire without side effects.',
-        inputSchema: {
-            ...projectIdSchema,
-            operation: z
-                .enum([
-                'create',
-                'list',
-                'delete',
-                'enable',
-                'disable',
-                'install_template',
-                'dry_run',
-                'list_logs',
-            ])
-                .describe('Operation: create | list | delete | enable | disable | install_template | dry_run | list_logs'),
-            hook: z
-                .object({
-                name: z.string().max(500).describe('Human-readable hook name').optional(),
-                description: z.string().max(10_000).describe('What this hook does').optional(),
-                trigger: z
-                    .enum(['on_spec_created', 'on_spec_status_change', 'on_drift_detected', 'on_commit'])
-                    .describe('Trigger: on_spec_created | on_spec_status_change | on_drift_detected | on_commit')
-                    .optional(),
-                filter: z
-                    .object({
-                    fromStatus: z
-                        .string()
-                        .max(500)
-                        .optional()
-                        .describe('Only fire when status changes FROM this'),
-                    toStatus: z
-                        .string()
-                        .max(500)
-                        .optional()
-                        .describe('Only fire when status changes TO this'),
-                    specIdPattern: z
-                        .string()
-                        .max(500)
-                        .optional()
-                        .describe('Only fire for specs matching this glob pattern (e.g. SPEC-*)'),
-                })
-                    .optional()
-                    .describe('Optional filter conditions for conditional firing'),
-                actions: z
-                    .array(z.object({
-                    type: z
-                        .enum(['run_tool', 'log_message', 'set_variable', 'notify'])
-                        .describe('Action type: run_tool | log_message | set_variable | notify'),
-                    tool: z.string().max(500).optional().describe('Tool name (for run_tool)'),
-                    args: z
-                        .record(z.string().max(500), z.unknown())
-                        .optional()
-                        .describe('Tool args (for run_tool)'),
-                    message: z
-                        .string()
-                        .max(10_000)
-                        .optional()
-                        .describe('Message template (for log_message/notify)'),
-                    key: z.string().max(500).optional().describe('Variable key (for set_variable)'),
-                    value: z
-                        .string()
-                        .max(10_000)
-                        .optional()
-                        .describe('Variable value (for set_variable)'),
-                }))
-                    .max(100)
-                    .optional()
-                    .describe('Ordered list of actions to execute when hook fires'),
-                enabled: z.boolean().optional().describe('Whether hook is active (default: true)'),
-            })
-                .optional()
-                .describe('Hook definition — required for create operation'),
-            hookId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Hook ID — required for delete, enable, disable, dry_run'),
-            templateName: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Template name — required for install_template. Options: sdd-full | ci-ready | quality-gate'),
-            dryRunPayload: z
-                .object({
-                trigger: z
-                    .enum(['on_spec_created', 'on_spec_status_change', 'on_drift_detected', 'on_commit'])
-                    .describe('Trigger type to simulate'),
-                projectId: z.string().max(500).describe('Project ID for the simulated event'),
-                timestamp: z.string().max(500).optional().describe('Event timestamp (defaults to now)'),
-                specId: z.string().max(500).optional().describe('Spec ID (for spec-related triggers)'),
-                specTitle: z.string().max(500).optional().describe('Spec title'),
-                specType: z.string().max(500).optional().describe('Spec type (for on_spec_created)'),
-                fromStatus: z
-                    .string()
-                    .max(500)
-                    .optional()
-                    .describe('Previous status (for on_spec_status_change)'),
-                toStatus: z
-                    .string()
-                    .max(500)
-                    .optional()
-                    .describe('New status (for on_spec_status_change)'),
-                driftScore: z.number().optional().describe('Drift score 0-100 (for on_drift_detected)'),
-                driftSummary: z
-                    .string()
-                    .max(10_000)
-                    .optional()
-                    .describe('Drift summary (for on_drift_detected)'),
-                commitHash: z.string().max(500).optional().describe('Commit hash (for on_commit)'),
-                commitMessage: z
-                    .string()
-                    .max(10_000)
-                    .optional()
-                    .describe('Commit message (for on_commit)'),
-                branch: z.string().max(500).optional().describe('Branch name (for on_commit)'),
-            })
-                .optional()
-                .describe('Simulated event payload for dry_run operation'),
-        },
-        annotations: { title: 'Manage Agent Hooks', readOnlyHint: false },
-    }, safeLicensed('manage_hooks', withProject((args) => handleManageHooks(args))));
-    // ── Filesystem Hooks ────────────────────────────────────────────────────────
-    s.registerTool('configure_filesystem_hooks', {
-        description: 'Configure reactive filesystem hooks for a project. ' +
-            'Hooks auto-trigger Planu tools when project files change (save, create, delete). ' +
-            'Use enable/disable to toggle the entire system, add-hook to register a new hook, ' +
-            'remove-hook to delete by index, list to view all hooks, or status to see current state.',
-        annotations: {
-            title: 'Configure Filesystem Hooks',
-            readOnlyHint: false,
-            destructiveHint: false,
-        },
-        inputSchema: {
-            action: z
-                .enum(['enable', 'disable', 'add-hook', 'remove-hook', 'list', 'status'])
-                .describe('Action to perform. Valid values: enable | disable | add-hook | remove-hook | list | status.'),
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root directory'),
-            hook: z
-                .object({
-                event: z
-                    .enum(['on_save', 'on_create', 'on_delete'])
-                    .describe('Filesystem event to watch. Valid values: on_save | on_create | on_delete.'),
-                pattern: z
-                    .string()
-                    .min(1)
-                    .max(500)
-                    .describe('Glob pattern to match (e.g. "src/**/*.ts", "*.json")'),
-                tool: z
-                    .string()
-                    .min(1)
-                    .max(200)
-                    .describe('Planu tool name to trigger when pattern matches (e.g. "validate")'),
-                args: z
-                    .record(z.string().max(200), z.unknown())
-                    .optional()
-                    .describe('Extra arguments to pass to the triggered tool'),
-                debounceMs: z
-                    .number()
-                    .min(0)
-                    .max(60000)
-                    .optional()
-                    .describe('Debounce window in milliseconds (default: 500)'),
-            })
-                .optional()
-                .describe('Hook definition — required when action is add-hook'),
-            hookIndex: z
-                .number()
-                .int()
-                .min(0)
-                .optional()
-                .describe('Zero-based index of the hook to remove — required for remove-hook action'),
-        },
-    }, safeLicensed('configure_filesystem_hooks', async (args) => handleConfigureFilesystemHooks({
-        action: args.action,
-        projectPath: args.projectPath,
-        hook: args.hook,
-        hookIndex: args.hookIndex,
-    })));
-    s.registerTool('filesystem_hooks_status', {
-        description: 'Check the current status of filesystem hooks for a project. ' +
-            'Returns whether hooks are enabled and how many are configured.',
-        annotations: {
-            title: 'Filesystem Hooks Status',
-            readOnlyHint: true,
-            destructiveHint: false,
-        },
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root directory'),
-        },
-    }, safeTracked('filesystem_hooks_status', async (args) => handleConfigureFilesystemHooks({ action: 'status', projectPath: args.projectPath })));
-    // ── Dep Audit ───────────────────────────────────────────────────────────────
-    s.registerTool('security_scan', {
-        description: 'Scan project dependencies for security vulnerabilities, license conflicts, and abandoned packages. ' +
-            'Free tier: npm critical CVEs only. Pro: all ecosystems, full severity breakdown.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root to audit'),
-            ecosystem: z
-                .enum(['npm', 'python', 'all'])
-                .optional()
-                .describe('Ecosystem filter: npm (Node.js), python, or all. Pro only for python/all. Default: npm'),
-            force_refresh: z
-                .boolean()
-                .optional()
-                .describe('Force synchronous CVE database refresh from OSV.dev before scanning, ignoring the 7-day cache.'),
-        },
-    }, safeTracked('security_scan', async (args) => {
-        const ecosystems = args.ecosystem === 'all'
-            ? ['npm', 'pip', 'go', 'cargo']
-            : args.ecosystem === 'python'
-                ? ['pip']
-                : ['npm'];
-        // SPEC-773: CVE database freshness check
-        const staleness = await isCveDatabaseStale();
-        if (args.force_refresh) {
-            await refreshCveDatabase(ecosystems);
-        }
-        else if (staleness.stale) {
-            // Fire-and-forget — scan proceeds immediately with current data
-            refreshCveDatabase(ecosystems).catch(() => undefined);
-        }
-        const report = await auditDeps(args.projectPath);
-        let text = buildFreeReport(report);
-        if (staleness.stale) {
-            text += `\n\n> ⚠️ CVE database is ${String(staleness.ageDays)} days old — refresh triggered in background. Run with force_refresh: true to wait for fresh data.`;
-        }
-        return { content: [{ type: 'text', text }] };
-    }));
-    s.registerTool('security_scan_pro', {
-        description: 'Full security scan across all ecosystems (npm, Python, Go, Rust, Java). ' +
-            'Reports critical → high → medium → low vulnerabilities, license conflicts, and abandoned packages. Requires Pro plan.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root to audit'),
-            ecosystem: z
-                .enum(['npm', 'python', 'all'])
-                .optional()
-                .describe('Ecosystem filter: npm, python, or all (default). Pro feature for python/all ecosystems.'),
-        },
-    }, safeLicensed('security_scan_pro', async (args) => {
-        const report = await auditDeps(args.projectPath);
-        const text = buildFullReport(report);
-        const cves = criticalVulnCves(report);
-        if (cves.length > 0) {
-            const warnText = `\n\n> CRITICAL CVEs detected: ${cves.join(', ')}. Address these before deploying to production.`;
-            return { content: [{ type: 'text', text: text + warnText }] };
-        }
-        return { content: [{ type: 'text', text }] };
-    }));
-    // ── Dependency Health (SPEC-967) ────────────────────────────────────────────
-    s.registerTool('dependency_health', {
-        description: 'Analyze project dependency health: detects unused, missing, outdated, ' +
-            'duplicated, and peer-conflicting dependencies. Returns a 0-100 score with actionable recommendations.',
-        annotations: { readOnlyHint: true, title: 'Dependency Health' },
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root to audit'),
-            ecosystem: z
-                .enum(['npm', 'python', 'rust', 'go'])
-                .optional()
-                .describe('Package ecosystem to analyze. Valid values: npm, python, rust, go. Default: npm'),
-        },
-    }, safeTracked('dependency_health', async (args) => {
-        const result = await handleDependencyHealth(args);
-        return result;
-    }));
-    // ── Changelog ───────────────────────────────────────────────────────────────
-    s.registerTool('spec_history', {
-        description: 'View the changelog history of a spec — see what changed, when, and why. ' +
-            'Shows criteria added/removed, status transitions, and reconciliation events. ' +
-            'Returns an empty list if no changelog exists yet for this spec.',
-        annotations: { title: 'Spec History', readOnlyHint: true },
-        inputSchema: {
-            specId: z
-                .string()
-                .min(1)
-                .max(500)
-                .describe('Spec ID to retrieve history for (e.g. "SPEC-067")'),
-            specDir: z
-                .string()
-                .max(4096)
-                .describe('Absolute path to the spec directory containing CHANGELOG.md'),
-            filter: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Filter by change type(s), comma-separated. ' +
-                'Valid values: criteria_added | criteria_removed | status_changed | scope_changed | progress_updated | reconciled'),
-        },
-    }, safeLicensed('spec_history', async (args) => handleSpecHistory(args)));
-    // ── Event ───────────────────────────────────────────────────────────────────
-    s.registerTool('event_contracts', {
-        description: 'Manage event-driven architecture contracts: generate JSON Schema contracts for events, ' +
-            'validate payloads, evolve schemas with backward-compatibility classification, ' +
-            'and define Saga contracts for distributed transactions.',
-        annotations: { readOnlyHint: false },
-        inputSchema: {
-            subcommand: z
-                .enum(['generate-contract', 'validate-contract', 'evolve-contract', 'saga-spec'])
-                .describe('generate-contract: create a new event contract JSON Schema; ' +
-                'validate-contract: verify a payload against the active contract; ' +
-                'evolve-contract: classify a schema change and apply the new version; ' +
-                'saga-spec: define a Saga with compensation events per step'),
-            ...projectIdSchema,
-            generateContract: z
-                .object({
-                projectId: z.string().min(1).max(500).describe('Project ID'),
-                eventName: z.string().max(500).describe('Unique event name, e.g. "order.created"'),
-                producer: z.string().max(500).describe('Service or component that emits this event'),
-                consumers: z
-                    .array(z.string().max(500))
-                    .max(100)
-                    .describe('Known consumer service names'),
-                payloadFields: z
-                    .array(z.object({
-                    name: z.string().max(500).describe('Field name'),
-                    type: z
-                        .string()
-                        .max(500)
-                        .describe('JSON Schema type: string, number, boolean, object, array'),
-                    required: z.boolean().describe('Whether this field is required'),
-                    description: z.string().max(10_000).optional().describe('Field description'),
-                }))
-                    .max(1000)
-                    .describe('Payload field definitions'),
-                broker: z
-                    .enum(['kafka', 'rabbitmq', 'sqs-sns', 'nats', 'eventbridge', 'pubsub', 'unknown'])
-                    .optional()
-                    .describe('Message broker (auto-detected from project stack if omitted)'),
-                specId: z
-                    .string()
-                    .max(500)
-                    .optional()
-                    .describe('SPEC-XXX that references this contract'),
-            })
-                .optional()
-                .describe('Input for generate-contract subcommand'),
-            validateContract: z
-                .object({
-                projectId: z.string().min(1).max(500).describe('Project ID'),
-                eventName: z.string().max(500).describe('Event name to validate against'),
-                payload: z
-                    .record(z.string().max(500), z.unknown())
-                    .describe('Payload object to validate'),
-            })
-                .optional()
-                .describe('Input for validate-contract subcommand'),
-            evolveContract: z
-                .object({
-                projectId: z.string().min(1).max(500).describe('Project ID'),
-                eventName: z.string().max(500).describe('Event name to evolve'),
-                changeDescription: z
-                    .string()
-                    .max(10_000)
-                    .describe('Human-readable description of the change'),
-                addedFields: z
-                    .array(z.string().max(500))
-                    .max(100)
-                    .optional()
-                    .describe('New optional fields added'),
-                removedFields: z
-                    .array(z.string().max(500))
-                    .max(100)
-                    .optional()
-                    .describe('Fields removed (breaking)'),
-                changedFields: z
-                    .array(z.object({
-                    field: z.string().max(500),
-                    from: z.string().max(500).describe('Previous type'),
-                    to: z.string().max(500).describe('New type'),
-                }))
-                    .max(100)
-                    .optional()
-                    .describe('Fields whose type changed (breaking)'),
-                deprecatedFields: z
-                    .array(z.object({
-                    field: z.string().max(500),
-                    reason: z.string().max(10_000),
-                    sunsetVersion: z
-                        .string()
-                        .max(500)
-                        .describe('Version at which field will be removed'),
-                }))
-                    .max(100)
-                    .optional()
-                    .describe('Fields marked deprecated'),
-            })
-                .optional()
-                .describe('Input for evolve-contract subcommand'),
-            sagaSpec: z
-                .object({
-                projectId: z.string().min(1).max(500).describe('Project ID'),
-                sagaId: z.string().max(500).describe('Unique Saga ID, e.g. "checkout-saga"'),
-                description: z.string().max(10_000).describe('What the Saga achieves'),
-                coordinationStyle: z
-                    .enum(['choreography', 'orchestration'])
-                    .describe('Coordination style'),
-                steps: z
-                    .array(z.object({
-                    id: z.string().max(500).describe('Unique step ID'),
-                    name: z.string().max(500).describe('Step name'),
-                    service: z.string().max(500).describe('Service executing this step'),
-                    successEvent: z.string().max(500).describe('Event emitted on step success'),
-                    failureEvent: z.string().max(500).describe('Event emitted on step failure'),
-                    compensationEvent: z
-                        .string()
-                        .max(500)
-                        .describe('Event that compensates / undoes this step'),
-                    failureConditions: z
-                        .array(z.string().max(500))
-                        .max(100)
-                        .describe('Conditions causing failure'),
-                    dependsOn: z
-                        .array(z.string().max(500))
-                        .max(100)
-                        .describe('Step IDs that must complete first'),
-                }))
-                    .max(100)
-                    .describe('Ordered Saga steps — each must have a compensationEvent'),
-                orchestratorService: z
-                    .string()
-                    .max(500)
-                    .optional()
-                    .describe('Orchestrator service name (required if orchestration style)'),
-                specId: z.string().max(500).optional().describe('SPEC-XXX implementing this Saga'),
-            })
-                .optional()
-                .describe('Input for saga-spec subcommand'),
-        },
-    }, safeLicensed('event_contracts', withProject((args) => handleEventContracts(args))));
-    // ── Feedback ────────────────────────────────────────────────────────────────
-    const FeedbackTypeEnum = z.enum(['bug', 'feature', 'suggestion', 'dx']);
-    s.registerTool('submit_feedback', {
-        description: 'Submit a bug report, feature request, or suggestion. Planu tracks it and links it to the spec that resolves it.',
-        inputSchema: {
-            type: FeedbackTypeEnum.describe('Feedback category. Values: bug | feature | suggestion | dx. ' +
-                'bug = software defect, feature = new capability, suggestion = improvement idea, dx = developer experience.'),
-            title: z
-                .string()
-                .min(1)
-                .describe('Short, descriptive title for the feedback (1-100 chars).'),
-            description: z
-                .string()
-                .min(1)
-                .describe('Detailed description of the issue, request, or suggestion.'),
-            context: z
-                .object({
-                projectPath: z
-                    .string()
-                    .optional()
-                    .describe('Absolute path to the project root where the issue occurred.'),
-                currentFile: z
-                    .string()
-                    .optional()
-                    .describe('File path where the issue was observed (relative to project root).'),
-                errorMessage: z.string().optional().describe('Exact error message if reporting a bug.'),
-                stack: z.string().optional().describe('Stack trace if available.'),
-            })
-                .optional()
-                .describe('Optional context to help reproduce or understand the feedback.'),
-        },
-        annotations: { title: 'Submit Feedback', destructiveHint: false },
-    }, safeTracked('submit_feedback', async (args) => handleSubmitFeedback(args)));
-    s.registerTool('triage_feedback', {
-        description: 'View and prioritize pending user feedback grouped by similarity. Shows which feedback should become specs.',
-        inputSchema: {
-            filter: FeedbackTypeEnum.optional().describe('Filter by feedback type. Values: bug | feature | suggestion | dx. Omit to show all types.'),
-        },
-        annotations: { title: 'Triage Feedback', readOnlyHint: true },
-    }, safeLicensed('triage_feedback', (args) => Promise.resolve(handleTriageFeedback(args))));
-    s.registerTool('resolve_feedback', {
-        description: 'Mark feedback as resolved, linking it to the spec and PR that fixed it.',
-        inputSchema: {
-            feedbackId: z.string().min(1).describe('Feedback entry ID to resolve (e.g. FB-042).'),
-            specId: z
-                .string()
-                .optional()
-                .describe('SPEC-XXX ID of the spec that addressed this feedback (e.g. SPEC-188).'),
-            prUrl: z
-                .string()
-                .optional()
-                .describe('GitHub PR URL that delivered the fix (e.g. https://github.com/org/repo/pull/123).'),
-            notes: z
-                .string()
-                .optional()
-                .describe('Optional resolution notes explaining how the feedback was addressed.'),
-        },
-        annotations: { title: 'Resolve Feedback', destructiveHint: false },
-    }, safeLicensed('resolve_feedback', async (args) => handleResolveFeedback(args)));
-    // ── Comments ────────────────────────────────────────────────────────────────
-    s.registerTool('add_comment', {
-        description: 'Add an inline comment to a spec. Comments can be anchored to a specific acceptance criterion (acIndex) and marked as blocking to prevent readiness approval.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-            specId: z
-                .string()
-                .describe('SPEC-XXX identifier of the spec to comment on (e.g. SPEC-042).'),
-            author: z.string().min(1).describe('Free-form author name or handle (e.g. "alice").'),
-            text: z.string().min(1).describe('Comment body text.'),
-            acIndex: z
-                .number()
-                .int()
-                .min(0)
-                .optional()
-                .describe('Optional 0-based index of the acceptance criterion this comment is anchored to.'),
-            blocking: z
-                .boolean()
-                .optional()
-                .describe('When true, check_readiness will fail while this comment is unresolved. Defaults to false.'),
-        },
-        annotations: { title: 'Add Comment', destructiveHint: false },
-    }, safeTracked('add_comment', async (args) => handleAddComment(args)));
-    s.registerTool('list_comments', {
-        description: 'List comments for a spec. Optionally filter by resolved status to see open discussions or archived resolutions.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-            specId: z
-                .string()
-                .describe('SPEC-XXX identifier of the spec whose comments to list (e.g. SPEC-042).'),
-            resolved: z
-                .boolean()
-                .optional()
-                .describe('Filter by resolved status. true = show only resolved comments, false = show only open comments. Omit to show all comments.'),
-        },
-        annotations: { title: 'List Comments', readOnlyHint: true },
-    }, safeTracked('list_comments', (args) => Promise.resolve(handleListComments(args))));
-    s.registerTool('resolve_comment', {
-        description: 'Mark a comment as resolved. The comment is archived (not deleted) so the discussion history is preserved.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-            specId: z
-                .string()
-                .describe('SPEC-XXX identifier of the spec the comment belongs to (e.g. SPEC-042).'),
-            commentId: z.string().describe('Comment ID to resolve (e.g. CMT-003).'),
-        },
-        annotations: { title: 'Resolve Comment', destructiveHint: false },
-    }, safeTracked('resolve_comment', async (args) => handleResolveComment(args)));
-    s.registerTool('reply_comment', {
-        description: 'Reply to an existing comment, creating a threaded discussion. The reply is linked to the parent comment via parentId.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root (e.g. /home/user/my-project).'),
-            specId: z
-                .string()
-                .describe('SPEC-XXX identifier of the spec the thread belongs to (e.g. SPEC-042).'),
-            parentId: z.string().describe('ID of the parent comment to reply to (e.g. CMT-001).'),
-            author: z.string().min(1).describe('Free-form author name or handle (e.g. "bob").'),
-            text: z.string().min(1).describe('Reply body text.'),
-        },
-        annotations: { title: 'Reply to Comment', destructiveHint: false },
-    }, safeTracked('reply_comment', async (args) => handleReplyComment(args)));
-    // ── Memory ──────────────────────────────────────────────────────────────────
-    s.registerTool('log_decision', {
-        description: 'Register, list, search, or supersede architectural and process decisions for a project. ' +
-            'Prevents re-debating settled choices across sessions. ' +
-            'Warns when a proposed change conflicts with an existing active decision.',
-        annotations: { readOnlyHint: false },
-        inputSchema: {
-            projectId: z
-                .string()
-                .max(500)
-                .describe('Project ID (hash of project path from init_project)'),
-            operation: z
-                .enum(['register', 'list', 'supersede', 'search'])
-                .describe('register: save a new decision | ' +
-                'list: show all decisions (filter by specId via query) | ' +
-                'supersede: mark a decision as replaced | ' +
-                'search: full-text search in decision history'),
-            decision: z
-                .object({
-                what: z.string().max(10_000).describe('What was decided (short declarative statement)'),
-                why: z.string().max(10_000).describe('Rationale — why this option was chosen'),
-                alternatives: z
-                    .array(z.string().max(10_000))
-                    .max(100)
-                    .optional()
-                    .describe('Alternatives that were considered but rejected'),
-                decidedBy: z
-                    .enum(['human', 'ai', 'both'])
-                    .optional()
-                    .describe('Who made the decision (default: both)'),
-                category: z
-                    .enum(['architecture', 'stack', 'ux', 'business', 'process'])
-                    .optional()
-                    .describe('Decision category — auto-inferred from content if omitted'),
-                specId: z
-                    .string()
-                    .max(500)
-                    .optional()
-                    .describe('Associate decision with a specific spec (e.g. "SPEC-001")'),
-            })
-                .optional()
-                .describe('Decision payload — required for operation "register"'),
-            decisionId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Decision ID to supersede — required for operation "supersede"'),
-            query: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Search query for operation "search"; ' +
-                'specId filter for operation "list" (optional)'),
-        },
-    }, safeLicensed('log_decision', async (args) => handleLogDecision(args)));
-    s.registerTool('reality_check', {
-        description: 'Evaluate whether a set of requirements is feasible given the project context. ' +
-            'Detects impossible timelines, contradictory requirements (offline + real-time sync), ' +
-            'performance paradoxes (fast + secure + cheap simultaneously), and scope creep. ' +
-            'Returns a FeasibilityReport with a score 0-100, issues with alternatives, and viability flag. ' +
-            'Score < 50 triggers a prominent warning.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            projectId: z
-                .string()
-                .max(500)
-                .describe('Project ID (hash of project path from init_project)'),
-            requirements: z
-                .array(z.string().max(10_000))
-                .min(1)
-                .max(1000)
-                .describe('List of requirements or user stories to evaluate. ' +
-                'Each item should describe one requirement or expectation.'),
-        },
-    }, safeLicensed('reality_check', async (args) => handleRealityCheck(args)));
-    // ── Infrastructure ──────────────────────────────────────────────────────────
-    s.registerTool('generate_infrastructure', {
-        description: 'Generate Infrastructure-as-Code (IaC) from a spec. ' +
-            'Analyzes spec text for infrastructure signals (database, cache, queue, storage, deployment) ' +
-            'and generates Terraform, Docker Compose, Kubernetes manifests, or Railway config. ' +
-            'Includes monthly cost estimates for detected services.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            ...projectIdSchema,
-            specId: z
-                .string()
-                .min(1)
-                .max(500)
-                .describe('Spec ID to analyze for infrastructure signals (e.g. SPEC-042)'),
-            formats: z
-                .array(z
-                .enum(['terraform', 'docker-compose', 'kubernetes', 'railway'])
-                .describe('Output format: terraform | docker-compose | kubernetes | railway'))
-                .max(4)
-                .optional()
-                .describe('IaC formats to generate: terraform | docker-compose | kubernetes | railway. ' +
-                'Default: [terraform, docker-compose]'),
-            environment: z
-                .enum(['dev', 'staging', 'prod'])
-                .optional()
-                .describe('Target environment: dev | staging | prod. ' +
-                'Affects instance sizing and cost estimates. Default: dev'),
-        },
-    }, safeTracked('generate_infrastructure', withProject((args) => handleGenerateInfrastructure(args))));
-    // ── Global Rules ────────────────────────────────────────────────────────────
-    s.registerTool('manage_global_rules', {
-        description: 'Manage global steering rules stored in ~/.planu/global-rules/. Rules can be applied to any project CLAUDE.md to inject consistent conventions.',
-        inputSchema: {
-            action: z
-                .enum(['create', 'list', 'get', 'update', 'delete', 'apply', 'export'])
-                .describe('Action to perform. Values: create (new rule), list (all rules), get (one rule), update (modify), delete (remove), apply (inject to CLAUDE.md), export (raw content).'),
-            slug: z
-                .string()
-                .optional()
-                .describe('Rule slug — kebab-case identifier (e.g. "no-any-types"). Required for get, update, delete, apply, export.'),
-            name: z.string().optional().describe('Human-readable rule name. Required for create.'),
-            content: z.string().optional().describe('Rule body in Markdown. Required for create.'),
-            tags: z
-                .array(z.string())
-                .optional()
-                .describe('Optional tag list for filtering (e.g. ["typescript", "quality"]).'),
-            author: z.string().optional().describe('Optional author identifier.'),
-            version: z
-                .string()
-                .optional()
-                .describe('Semver version string (e.g. "1.0.0"). Defaults to "1.0.0".'),
-            projectPath: z
-                .string()
-                .optional()
-                .describe('Absolute project path. Required for apply action.'),
-        },
-        annotations: { title: 'Manage Global Rules', destructiveHint: false },
-    }, safeTracked('manage_global_rules', async (args) => handleManageGlobalRules(args)));
-    s.registerTool('global_rules_status', {
-        description: 'Show a summary of all global steering rules stored in ~/.planu/global-rules/.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .optional()
-                .describe('Optional project path (unused, for context only).'),
-        },
-        annotations: { title: 'Global Rules Status', readOnlyHint: true },
-    }, safeTracked('global_rules_status', async (args) => handleGlobalRulesStatus(args)));
-    // ── Plan Mode ───────────────────────────────────────────────────────────────
-    s.registerTool('plan_mode', {
-        description: 'Generate a diff preview plan for a spec before implementing. Shows which files will be created or modified, estimated line changes, risk level, and warnings — without touching any code.',
-        inputSchema: {
-            specId: z.string().describe('Spec ID to plan (e.g. SPEC-473). Must be in the project.'),
-            projectPath: z.string().describe('Absolute path to the project root.'),
-        },
-        annotations: { title: 'Plan Mode — Diff Preview', readOnlyHint: true },
-    }, safeTracked('plan_mode', async (args) => handlePlanMode(args)));
-    // ── implement_plan (migrated to skill, SPEC-658) ──────────────────────────────
-    // Tool stays registered for backward compat; callers receive a deprecation notice.
-    registerFromEntries(s, [
-        makeDeprecationStub('implement_plan', '.claude/skills/implement-spec.md', 'implement-spec'),
-    ]);
-    // ── Quality Gates ───────────────────────────────────────────────────────────
-    s.registerTool('inject_quality_gates', {
-        description: 'Inject security, testing, architecture, and performance quality gate criteria ' +
-            'into a spec automatically based on the project stack and spec risk level. ' +
-            'Gates are appended as a "## Quality Gates [AUTO]" section in the spec.md file. ' +
-            'Use profile to control which categories are injected: ' +
-            'strict (all 4 categories), standard (security+testing+architecture), ' +
-            'minimal (security+testing only). ' +
-            'Gates are filtered by spec type, risk level, and detected stack (typescript/python/java/go/generic).',
-        annotations: { readOnlyHint: false },
-        inputSchema: {
-            ...projectIdSchema,
-            specId: z
-                .string()
-                .min(1)
-                .max(500)
-                .describe('Spec ID to inject quality gates into (e.g. SPEC-042)'),
-            profile: z
-                .enum(['strict', 'standard', 'minimal'])
-                .optional()
-                .describe('Gate profile: strict (all categories), standard (security+testing+architecture), ' +
-                'minimal (security+testing only). Defaults to standard.'),
-            categories: z
-                .array(z.enum(['security', 'testing', 'architecture', 'performance']))
-                .optional()
-                .describe('Override gate categories to inject. Valid values: security, testing, architecture, performance. ' +
-                'If omitted, profile is used.'),
-        },
-    }, safeLicensed('inject_quality_gates', withProject((args) => {
-        const { projectId, specId, profile, categories } = args;
-        return handleInjectQualityGates(projectId, specId, { profile, categories });
-    })));
-    // ── Verifier (empty shim — tools moved to register-compliance-tools.ts) ─────
-    // verify_spec_compliance and compliance_score_report are registered in
-    // group-quality-compliance.ts as shims for check_compliance(mode).
-    // See SPEC-557 for the consolidation rationale.
-    // ── Context Profile ─────────────────────────────────────────────────────────
-    s.registerTool('set_context_profile', {
-        description: 'Activate a work-phase context profile that guides the LLM to use only the ' +
-            'relevant tools for the current phase (brainstorm/plan/implement/review/release). ' +
-            'Reduces token waste by surfacing only the ~10 most relevant tools per phase.',
-        inputSchema: {
-            projectPath: projectPathField,
-            phase: phaseField,
-        },
-        annotations: { readOnlyHint: false },
-    }, safeTracked('set_context_profile', async (args) => {
-        const { projectPath, phase } = args;
-        await setActiveProfile(projectPath, phase);
-        const profile = getProfile(phase);
-        // SPEC-508: Apply real tool-group filtering via GroupManager (fire-and-forget)
-        void import('../tool-group-handler.js')
-            .then(({ getGroupManager }) => {
-            const manager = getGroupManager();
-            if (!manager) {
-                return;
-            }
-            const phaseGroups = {
-                brainstorm: {
-                    enable: ['spec-lifecycle'],
-                    disable: [
-                        'analysis',
-                        'generation',
-                        'orchestration',
-                        'devops',
-                        'governance',
-                        'learning',
-                    ],
-                },
-                plan: {
-                    enable: ['spec-lifecycle', 'analysis'],
-                    disable: ['generation', 'orchestration', 'devops', 'governance', 'learning'],
-                },
-                implement: {
-                    enable: ['spec-lifecycle', 'generation'],
-                    disable: ['analysis', 'orchestration', 'devops', 'governance', 'learning'],
-                },
-                review: {
-                    enable: ['spec-lifecycle', 'analysis', 'governance'],
-                    disable: ['generation', 'orchestration', 'devops', 'learning'],
-                },
-                release: {
-                    enable: ['spec-lifecycle', 'devops'],
-                    disable: ['analysis', 'generation', 'orchestration', 'governance', 'learning'],
-                },
-                quickstart: {
-                    enable: ['spec-lifecycle'],
-                    disable: [
-                        'analysis',
-                        'generation',
-                        'orchestration',
-                        'devops',
-                        'governance',
-                        'learning',
-                    ],
-                },
-            };
-            const plan = phaseGroups[phase];
-            for (const id of plan.enable) {
-                manager.enableGroup(id);
-            }
-            for (const id of plan.disable) {
-                manager.disableGroup(id);
-            }
-        })
-            .catch(() => {
-            /* best-effort — never blocks response */
-        });
-        const focusList = profile.focusTools.map((tmpl) => `  • ${tmpl}`).join('\n');
-        const tipsList = profile.tips.map((tmpl) => `  - ${tmpl}`).join('\n');
-        const text = `You are now in **${profile.name}**.\n\n` +
-            `${profile.description}\n\n` +
-            `**Focus tools (~${profile.estimatedTokensSaved}% token savings):**\n${focusList}\n\n` +
-            `**Tips:**\n${tipsList}`;
-        return { content: [{ type: 'text', text }] };
-    }));
-    s.registerTool('get_context_profile', {
-        description: 'Get the currently active context profile for a project, ' +
-            'including focus tools and phase-specific tips. ' +
-            'Returns a prompt when no profile is active.',
-        inputSchema: {
-            projectPath: projectPathField,
-        },
-        annotations: { readOnlyHint: true },
-    }, safeTracked('get_context_profile', async (args) => {
-        const { projectPath } = args;
-        const active = await getActiveProfile(projectPath);
-        if (!active) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'No active context profile. Use set_context_profile to activate one.\n\n' +
-                            `Available phases: ${AVAILABLE_PHASES.join(', ')}`,
-                    },
-                ],
-            };
-        }
-        const profile = getProfile(active.phase);
-        const focusList = profile.focusTools.map((tmpl) => `  • ${tmpl}`).join('\n');
-        const avoidList = profile.avoidTools.map((tmpl) => `  • ${tmpl}`).join('\n');
-        const tipsList = profile.tips.map((tmpl) => `  - ${tmpl}`).join('\n');
-        const text = `**Active profile: ${profile.name}**\n` +
-            `Activated: ${active.activatedAt}\n\n` +
-            `${profile.description}\n\n` +
-            `**Focus tools:**\n${focusList}\n\n` +
-            `**Avoid tools:**\n${avoidList}\n\n` +
-            `**Tips:**\n${tipsList}\n\n` +
-            `Estimated token savings: ~${profile.estimatedTokensSaved}%`;
-        return { content: [{ type: 'text', text }] };
-    }));
-    s.registerTool('list_context_profiles', {
-        description: 'List all 5 available context profiles (brainstorm/plan/implement/review/release) ' +
-            'with their focus tools and estimated token savings. ' +
-            'Use this to discover which profile is best for the current work.',
-        inputSchema: {
-            projectPath: projectPathField,
-        },
-        annotations: { readOnlyHint: true },
-    }, safeTracked('list_context_profiles', async (args) => {
-        const { projectPath } = args;
-        const active = await getActiveProfile(projectPath);
-        const profiles = getAllProfiles();
-        const lines = ['**Available context profiles:**\n'];
-        for (const p of profiles) {
-            const isActive = active?.phase === p.phase ? ' (ACTIVE)' : '';
-            lines.push(`### ${p.name}${isActive}`, `Phase: \`${p.phase}\``, p.description, `Focus: ${p.focusTools.slice(0, 5).join(', ')}${p.focusTools.length > 5 ? ` +${String(p.focusTools.length - 5)} more` : ''}`, `Token savings: ~${String(p.estimatedTokensSaved)}%`, '');
-        }
-        lines.push(`Use set_context_profile with phase=<phase> to activate one.`);
-        return { content: [{ type: 'text', text: lines.join('\n') }] };
-    }));
-    // ── configure_permissions (SPEC-594) ─────────────────────────────────────────
-    s.registerTool('configure_permissions', {
-        description: 'Auto-configure Claude Code permissions in .claude/settings.json (project-level only — ' +
-            'NEVER touches ~/.claude/settings.json). Writes an idempotent allow/deny list based on ' +
-            'the chosen mode and the detected project stack (Vercel, Supabase, Prisma, Docker, etc.). ' +
-            'Preserves all existing user entries; deny rules are always additive; defaultMode is never downgraded. ' +
-            'Use dryRun:true to preview changes without writing.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root. .claude/settings.json will be written here.'),
-            mode: z
-                .enum(['minimal', 'recommended', 'full'])
-                .default('recommended')
-                .describe('Permission mode: ' +
-                'minimal=only mcp__planu__* + always-deny rules; ' +
-                'recommended=above + dev tooling + git reads + FS reads + Claude Code native tools; ' +
-                'full=above + Bash(*) blanket (deny still wins)'),
-            dryRun: z
-                .boolean()
-                .optional()
-                .default(false)
-                .describe('When true, compute and return the merge plan without writing any files.'),
-        },
-    }, safeLicensed('configure_permissions', async (args) => {
-        const { handleConfigurePermissions } = await import('../configure-permissions.js');
-        const { projectPath, mode, dryRun } = args;
-        return handleConfigurePermissions({ projectPath, mode, dryRun });
-    }));
-    // ── install_plugins (SPEC-596) ─────────────────────────────────────────────
-    s.registerTool('install_plugins', {
-        description: 'Auto-register the official Anthropic Claude Code plugin marketplace and install ' +
-            'recommended plugins based on the detected project stack. ' +
-            'Idempotent: already-registered marketplace and already-installed plugins are skipped. ' +
-            'Safe when `claude` CLI is absent — skips silently with a warning. ' +
-            'Use dryRun:true to preview the install plan without any side effects.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root. Used to detect stack signals.'),
-            mode: z
-                .enum(['minimal', 'recommended', 'full'])
-                .default('recommended')
-                .describe('Installation mode: ' +
-                'minimal=always-tier plugins only (commit-commands); ' +
-                'recommended=above + stack-matched plugins per detected stack; ' +
-                'full=above + all catalog plugins for detected stacks'),
-            stackHint: z
-                .array(z.string())
-                .optional()
-                .describe('Optional extra stack hints to force-include, e.g. ["vercel", "react"]. ' +
-                'Merged with auto-detected stack signals at high confidence.'),
-            dryRun: z
-                .boolean()
-                .optional()
-                .default(false)
-                .describe('When true, return the install plan without executing any CLI commands.'),
-        },
-    }, safeLicensed('install_plugins', async (args) => {
-        const { handleInstallPlugins } = await import('../install-plugins.js');
-        const { projectPath, mode, stackHint, dryRun } = args;
-        return handleInstallPlugins({ projectPath, mode, stackHint, dryRun });
-    }));
-    // ── SPEC-966: OpenCode Host Adapter ──────────────────────────────────────────
-    s.registerTool('opencode_host_adapter', {
-        description: 'Detect, scaffold, or coach OpenCode workspace integration for Planu. ' +
-            'Equivalent to Claude Code / Codex / Gemini adapters. ' +
-            'Actions: detect (find workspace markers), scaffold (generate .opencode/rules/, .opencode/skills/, AGENTS.md), ' +
-            'coach (list OpenCode-specific SDD rules).',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root'),
-            action: z
-                .enum(['detect', 'scaffold', 'coach'])
-                .describe('Action: detect — find workspace; scaffold — generate config files; coach — list rules'),
-        },
-        annotations: { title: 'OpenCode Host Adapter', readOnlyHint: false },
-    }, safeTracked('opencode_host_adapter', (args) => handleOpenCodeHostAdapter({
-        projectPath: args.projectPath,
-        action: args.action,
-    })));
-}
-//# sourceMappingURL=group-platform.js.map