@planu/cli 3.9.9 → 3.9.11

package/dist/tools/tool-registry/group-analysis-monitoring.js

@@ -0,0 +1,942 @@
+/* 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-analysis-monitoring.ts — Declarative registry: analysis & monitoring tools.
+//
+// Phase 3 (refactor/registry-phase3): consolidates register-*.ts files for:
+//   analytics-report, code-impact, dependency-impact, tech-debt,
+//   drift-monitor, drift-watcher (empty shim), manage-drift,
+//   code-graph, estimation-accuracy, team-analytics,
+//   spec-scheduler, crash-shield, self-healing, auto-remediation, auto-promoter
+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';
+// ── Analytics report (register-analytics-report-tools.ts) ────────────────────
+import { handleAnalyticsReport } from '../analytics-report-handler.js';
+import { handleSpecEffectivenessScore } from '../spec-effectiveness-score.js';
+import { toolResult, formatError } from '../response-helpers.js';
+// ── Code impact (register-code-impact-tools.ts) ───────────────────────────────
+import { handleAnalyzeCodeImpact, handleCodeChangeCompliance, handleSuggestSpecUpdate, handleGitDiffToSpecImpact, } from '../code-impact-handler.js';
+// ── Dependency impact (register-dependency-impact-tools.ts) ───────────────────
+import { handleRegisterApiSurface, handleAnalyzeBreakingChanges, handleDependencyImpactReport, handleCheckApiCompatibility, } from '../dependency-impact-handler.js';
+// ── Tech debt (register-tech-debt-tools.ts) ───────────────────────────────────
+import { handleTrackTechDebt, handleTechDebtBudget, handleListTechDebt, handleDebtForecast, handleResolveTechDebt, } from '../tech-debt-handler.js';
+// ── Drift monitor (register-drift-monitor-tools.ts) ───────────────────────────
+import { handleConfigureDriftMonitoring, handleDriftAlertRules, } from '../drift-monitor-handler.js';
+// ── Manage drift (register-manage-drift-tool.ts) ──────────────────────────────
+import { handleManageDrift } from '../manage-drift-handler.js';
+// ── Code graph (register-code-graph-tools.ts) ─────────────────────────────────
+import { handleConfigureCodeGraph, handleCodeGraphStatus } from '../code-graph-handler.js';
+// ── Estimation accuracy (register-estimation-accuracy-tools.ts) ───────────────
+import { handleRecordActual, handleCalibrateEstimates } from '../estimation-accuracy-handler.js';
+// ── Team analytics (register-team-analytics-tools.ts) ────────────────────────
+import { handleWorkloadDistribution } from '../team-analytics-handler.js';
+// ── Spec scheduler (register-spec-scheduler-tools.ts) ────────────────────────
+import { handleSimulateParallelExecution, handleCriticalPathAnalyzer, handleParallelEfficiencyScore, handleOptimizeSpecScheduling, } from '../spec-scheduler-handler.js';
+// ── Crash shield (register-crash-shield-tools.ts) ────────────────────────────
+import { handleScanCrashRisks, handleFixCrashRisks, handleConfigureCrashRules, ScanCrashRisksSchema, FixCrashRisksSchema, ConfigureCrashRulesSchema, } from '../crash-shield-handler.js';
+// ── Self healing (register-self-healing-tools.ts) ────────────────────────────
+import { handleAutoFixValidation } from '../auto-fix-validation.js';
+import { autoFixHealth } from '../../engine/health/auto-fixer.js';
+import { hashProjectPath } from '../../storage/base-store.js';
+// ── Auto remediation (register-auto-remediation.ts) ──────────────────────────
+import { autoRemediateCompliance } from '../../engine/compliance/auto-remediator.js';
+// ── Auto promoter (register-auto-promoter-tools.ts) ──────────────────────────
+import { handleConfigureAutoPromotion, handleCheckAutoPromotion, } from '../auto-promoter-handler.js';
+// ── Observatory insights (SPEC-572) ───────────────────────────────────────────
+import { handleObservatoryInsights } from '../observatory-insights.js';
+// ── Multi-teammate review (SPEC-593) ──────────────────────────────────────────
+import { registerMultiTeammateReviewTool } from '../multi-teammate-review.js';
+// ── Code duplication detection (SPEC-970) ────────────────────────────────────
+import { handleDetectDuplication } from '../detect-duplication.js';
+// ---------------------------------------------------------------------------
+// Shared schema constants
+// ---------------------------------------------------------------------------
+const REPORT_TYPE_VALUES = [
+    'velocity',
+    'velocity-trend',
+    'tech-debt',
+    'estimation-accuracy',
+    'team',
+];
+const SEVERITY_ENUM = z
+    .enum(['low', 'medium', 'high', 'critical'])
+    .describe('Severity level. Values: low, medium, high, critical.');
+const CATEGORY_ENUM = z
+    .enum(['testing', 'documentation', 'refactoring', 'architecture', 'security'])
+    .describe('Category. Values: testing, documentation, refactoring, architecture, security.');
+const STATUS_ENUM = z
+    .enum(['open', 'resolved', 'all'])
+    .describe('Filter by status. Values: open, resolved, all.');
+const SURFACE_TYPE_ENUM = z
+    .enum(['rest-endpoint', 'graphql', 'typescript-interface', 'database-schema', 'event'])
+    .describe('Surface type. Values: rest-endpoint, graphql, typescript-interface, database-schema, event.');
+const surfaceSchema = z.object({
+    type: SURFACE_TYPE_ENUM,
+    definition: z.string().min(1).max(500).describe('Description of the surface.'),
+    isBreakingIfRemoved: z
+        .boolean()
+        .optional()
+        .describe('Whether removing this surface would be a breaking change.'),
+});
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+// eslint-disable-next-line max-lines-per-function -- registration catalog: one block per tool, each ~20 lines
+export function registerAnalysisMonitoringGroupTools(s) {
+    // ── Analytics report ─────────────────────────────────────────────────────────
+    s.registerTool('analytics_report', {
+        description: 'Unified analytics report. Consolidates velocity_report, velocity_trend, ' +
+            'tech_debt_report, estimation_accuracy_report, and team_analytics into a single tool. ' +
+            'Choose the report type via the `type` parameter.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            type: z
+                .enum(REPORT_TYPE_VALUES)
+                .describe('Report type. Values: velocity, velocity-trend, tech-debt, estimation-accuracy, team'),
+            projectPath: z
+                .string()
+                .min(1)
+                .max(4096)
+                .optional()
+                .describe('Absolute path to the project root (required for most report types).'),
+            projectId: z
+                .string()
+                .min(1)
+                .max(256)
+                .optional()
+                .describe('Project ID (alternative to projectPath for estimation-accuracy).'),
+            window: z
+                .number()
+                .int()
+                .min(1)
+                .max(365)
+                .optional()
+                .default(30)
+                .describe('Days window for metrics (default: 30).'),
+        },
+    }, safeTracked('analytics_report', async (args) => handleAnalyticsReport(args)));
+    // Deprecated shims
+    s.registerTool('velocity_report', {
+        description: '[DEPRECATED] Use analytics_report({ type: "velocity" }) instead. Generate a velocity metrics report: throughput, lead time, cycle time, WIP, flow efficiency.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            weeks: z.number().int().min(1).max(52).optional().describe('Number of weeks to analyze.'),
+            window: z
+                .number()
+                .int()
+                .min(1)
+                .max(365)
+                .optional()
+                .describe('Days window (ignored; use weeks).'),
+        },
+    }, safeTracked('velocity_report', async (args) => {
+        const window = args.weeks ? args.weeks * 7 : 30;
+        const result = await handleAnalyticsReport({
+            type: 'velocity',
+            projectPath: args.projectPath,
+            window,
+        });
+        const deprecationNote = '⚠️ velocity_report is deprecated — use analytics_report({ type: "velocity" }) instead\n\n';
+        const firstContent = result.content[0];
+        if (firstContent) {
+            return {
+                ...result,
+                content: [
+                    { ...firstContent, text: deprecationNote + firstContent.text },
+                    ...result.content.slice(1),
+                ],
+            };
+        }
+        return result;
+    }));
+    s.registerTool('velocity_trend', {
+        description: '[DEPRECATED] Use analytics_report({ type: "velocity-trend" }) instead. Compare team velocity between last N weeks and previous N weeks.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            compareWeeks: z
+                .number()
+                .int()
+                .min(1)
+                .max(26)
+                .optional()
+                .describe('Weeks per comparison window.'),
+        },
+    }, safeTracked('velocity_trend', async (args) => {
+        const window = args.compareWeeks ? args.compareWeeks * 2 * 7 : 56;
+        const result = await handleAnalyticsReport({
+            type: 'velocity-trend',
+            projectPath: args.projectPath,
+            window,
+        });
+        const deprecationNote = '⚠️ velocity_trend is deprecated — use analytics_report({ type: "velocity-trend" }) instead\n\n';
+        const firstContent = result.content[0];
+        if (firstContent) {
+            return {
+                ...result,
+                content: [
+                    { ...firstContent, text: deprecationNote + firstContent.text },
+                    ...result.content.slice(1),
+                ],
+            };
+        }
+        return result;
+    }));
+    s.registerTool('tech_debt_report', {
+        description: '[DEPRECATED] Use analytics_report({ type: "tech-debt" }) instead. Generate an HTML report of all tech debt items.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+        },
+    }, safeTracked('tech_debt_report', async (args) => {
+        if (!args.projectPath) {
+            return toolResult(formatError('projectPath is required'), undefined, true);
+        }
+        const result = await handleAnalyticsReport({
+            type: 'tech-debt',
+            projectPath: args.projectPath,
+        });
+        const deprecationNote = '⚠️ tech_debt_report is deprecated — use analytics_report({ type: "tech-debt" }) instead\n\n';
+        const firstContent = result.content[0];
+        if (firstContent) {
+            return {
+                ...result,
+                content: [
+                    { ...firstContent, text: deprecationNote + firstContent.text },
+                    ...result.content.slice(1),
+                ],
+            };
+        }
+        return result;
+    }));
+    s.registerTool('estimation_accuracy_report', {
+        description: '[DEPRECATED] Use analytics_report({ type: "estimation-accuracy" }) instead. Generate a historical estimation accuracy report.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z
+                .string()
+                .min(1)
+                .max(4096)
+                .optional()
+                .describe('Absolute path to the project root.'),
+            projectId: z.string().min(1).max(256).optional().describe('Project ID.'),
+        },
+    }, safeTracked('estimation_accuracy_report', async (args) => {
+        const result = await handleAnalyticsReport({
+            type: 'estimation-accuracy',
+            projectPath: args.projectPath,
+            projectId: args.projectId,
+        });
+        const deprecationNote = '⚠️ estimation_accuracy_report is deprecated — use analytics_report({ type: "estimation-accuracy" }) instead\n\n';
+        const firstContent = result.content[0];
+        if (firstContent) {
+            return {
+                ...result,
+                content: [
+                    { ...firstContent, text: deprecationNote + firstContent.text },
+                    ...result.content.slice(1),
+                ],
+            };
+        }
+        return result;
+    }));
+    s.registerTool('team_analytics', {
+        description: '[DEPRECATED] Use analytics_report({ type: "team" }) instead. Generate per-member performance metrics.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            weeks: z.number().int().min(1).max(52).optional().describe('Number of weeks to analyze.'),
+        },
+    }, safeTracked('team_analytics', async (args) => {
+        const window = args.weeks ? args.weeks * 7 : 28;
+        const result = await handleAnalyticsReport({
+            type: 'team',
+            projectPath: args.projectPath,
+            window,
+        });
+        const deprecationNote = '⚠️ team_analytics is deprecated — use analytics_report({ type: "team" }) instead\n\n';
+        const firstContent = result.content[0];
+        if (firstContent) {
+            return {
+                ...result,
+                content: [
+                    { ...firstContent, text: deprecationNote + firstContent.text },
+                    ...result.content.slice(1),
+                ],
+            };
+        }
+        return result;
+    }));
+    // ── Spec Effectiveness Score (SPEC-611) ──────────────────────────────────
+    s.registerTool('spec_effectiveness_score', {
+        description: 'Compute the Spec Effectiveness Score for a spec or aggregate across the project. Composite 0-100 score from adherence rate, first-pass success, rework ratio, estimation accuracy, and drift frequency. Pass specId for per-spec; omit or set aggregate=true for project-wide report with trends and patterns.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            specId: z
+                .string()
+                .min(1)
+                .max(256)
+                .optional()
+                .describe('Spec ID for per-spec score. Omit for project-wide report.'),
+            aggregate: z
+                .boolean()
+                .optional()
+                .describe('When true, return project-level aggregate report instead of per-spec.'),
+            projectPath: z
+                .string()
+                .min(1)
+                .max(4096)
+                .optional()
+                .describe('Absolute path to the project root.'),
+            projectId: z.string().min(1).max(256).optional().describe('Project ID.'),
+        },
+    }, safeTracked('spec_effectiveness_score', async (args) => handleSpecEffectivenessScore(args)));
+    // ── Code impact ──────────────────────────────────────────────────────────────
+    s.registerTool('analyze_code_impact', {
+        description: 'Analyze which specs are impacted by a code change. Provide filePath, diffText, or both. Returns related specs with relation type: direct-binding, filename-match, or semantic-match.',
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            filePath: z
+                .string()
+                .optional()
+                .describe('Path to the changed file (relative or absolute).'),
+            diffText: z
+                .string()
+                .optional()
+                .describe('Raw diff text (e.g. output of git diff). Used for semantic matching.'),
+        },
+        annotations: { title: 'Analyze Code Impact', readOnlyHint: true },
+    }, safeTracked('analyze_code_impact', (args) => handleAnalyzeCodeImpact(args)));
+    s.registerTool('code_change_compliance', {
+        description: 'Check whether a code change is justified by an approved spec. Returns a compliance score (0-100%), justifying specs, and unjustified changes.',
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            filePath: z
+                .string()
+                .optional()
+                .describe('Path to the changed file to check compliance for.'),
+            commitHash: z
+                .string()
+                .optional()
+                .describe('Git commit hash to analyze (uses git show internally).'),
+        },
+        annotations: { title: 'Code Change Compliance', readOnlyHint: true },
+    }, safeTracked('code_change_compliance', (args) => handleCodeChangeCompliance(args)));
+    s.registerTool('suggest_spec_update', {
+        description: 'Suggest which specs to update (or create) based on a changed file. Returns a list of suggestions with type (update/create), spec ID, and reason.',
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            filePath: z.string().min(1).max(4096).describe('Path to the changed file.'),
+        },
+        annotations: { title: 'Suggest Spec Update', readOnlyHint: true },
+    }, safeTracked('suggest_spec_update', (args) => handleSuggestSpecUpdate(args)));
+    s.registerTool('git_diff_to_spec_impact', {
+        description: 'Run git diff HEAD on the project and analyze which specs are impacted. Convenience alias that combines git diff + analyze_code_impact.',
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+        },
+        annotations: { title: 'Git Diff to Spec Impact', readOnlyHint: true },
+    }, safeTracked('git_diff_to_spec_impact', (args) => handleGitDiffToSpecImpact(args)));
+    // ── Dependency impact ────────────────────────────────────────────────────────
+    s.registerTool('register_api_surface', {
+        description: 'Register or update the API surfaces exposed by a spec (REST endpoints, GraphQL schemas, TypeScript interfaces, database schemas, or events).',
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            specId: z.string().min(1).describe('ID of the spec that exposes these surfaces.'),
+            surfaces: z.array(surfaceSchema).min(1).describe('List of API surface definitions.'),
+        },
+    }, safeTracked('register_api_surface', async (args) => handleRegisterApiSurface(args)));
+    s.registerTool('analyze_breaking_changes', {
+        description: "Analyze which other specs may be impacted by a change to a spec's API surface. Returns affected specs with impact level (high/medium/low).",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            specId: z.string().min(1).describe('ID of the spec being changed.'),
+            changeDescription: z
+                .string()
+                .min(1)
+                .max(1000)
+                .describe('Description of the change being made.'),
+        },
+    }, safeTracked('analyze_breaking_changes', async (args) => handleAnalyzeBreakingChanges(args)));
+    s.registerTool('dependency_impact_report', {
+        description: 'Generate an HTML report of specs affected by a change, including impact classification.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            specId: z.string().min(1).describe('ID of the spec being changed.'),
+            changeDescription: z
+                .string()
+                .min(1)
+                .max(1000)
+                .describe('Description of the change being made.'),
+        },
+    }, safeTracked('dependency_impact_report', async (args) => handleDependencyImpactReport(args)));
+    s.registerTool('check_api_compatibility', {
+        description: "Check which other specs depend on a given spec's API surfaces, helping identify compatibility risks.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            specId: z.string().min(1).describe('ID of the spec to check compatibility for.'),
+        },
+    }, safeTracked('check_api_compatibility', async (args) => handleCheckApiCompatibility(args)));
+    // ── Tech debt ────────────────────────────────────────────────────────────────
+    s.registerTool('track_tech_debt', {
+        description: 'Track a new tech debt item for a project. Records description, estimated hours, severity, and category.',
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            description: z.string().min(1).max(500).describe('Description of the tech debt.'),
+            estimatedHours: z
+                .number()
+                .min(0.5)
+                .max(1000)
+                .describe('Estimated hours to resolve this debt.'),
+            severity: SEVERITY_ENUM,
+            category: CATEGORY_ENUM,
+            specId: z.string().optional().describe('Optional spec ID this debt is linked to.'),
+        },
+    }, safeTracked('track_tech_debt', async (args) => handleTrackTechDebt(args)));
+    s.registerTool('tech_debt_budget', {
+        description: 'Configure tech debt budget limits: max hours allowed, max percent of backlog, and alert threshold.',
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            maxHours: z
+                .number()
+                .min(1)
+                .optional()
+                .describe('Maximum total open hours of tech debt allowed.'),
+            maxPercentOfBacklog: z
+                .number()
+                .min(1)
+                .max(100)
+                .optional()
+                .describe('Maximum tech debt as a percentage of backlog hours.'),
+            alertThreshold: z
+                .number()
+                .min(1)
+                .max(100)
+                .optional()
+                .describe('Percentage of budget that triggers an alert.'),
+        },
+    }, safeTracked('tech_debt_budget', async (args) => handleTechDebtBudget(args)));
+    s.registerTool('list_tech_debt', {
+        description: 'List tech debt items for a project, optionally filtered by status, severity, or category.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            status: STATUS_ENUM.optional().default('open'),
+            severity: SEVERITY_ENUM.optional(),
+            category: CATEGORY_ENUM.optional(),
+        },
+    }, safeTracked('list_tech_debt', async (args) => handleListTechDebt(args)));
+    s.registerTool('debt_forecast', {
+        description: 'Forecast tech debt growth based on historical accumulation rate. Projects weeks until budget is exceeded.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+        },
+    }, safeTracked('debt_forecast', async (args) => handleDebtForecast(args)));
+    s.registerTool('resolve_tech_debt', {
+        description: 'Mark a tech debt item as resolved.',
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            id: z.string().min(1).describe('ID of the tech debt item to resolve.'),
+            resolvedNotes: z
+                .string()
+                .max(500)
+                .optional()
+                .describe('Optional notes on how it was resolved.'),
+        },
+    }, safeTracked('resolve_tech_debt', async (args) => handleResolveTechDebt(args)));
+    // ── Drift monitor ────────────────────────────────────────────────────────────
+    s.registerTool('configure_drift_monitoring', {
+        description: 'Configure continuous drift monitoring for a project. Drift monitoring detects when code diverges from its spec over time.',
+        inputSchema: {
+            projectPath: z.string().describe('Absolute path to the project root.'),
+            action: z
+                .enum(['enable', 'disable', 'set-threshold', 'set-schedule', 'status'])
+                .describe('Action to perform. Values: enable, disable, set-threshold, set-schedule, status.'),
+            threshold: z
+                .number()
+                .min(0)
+                .max(100)
+                .optional()
+                .describe('Drift score (0–100) above which alerts fire. Used with set-threshold.'),
+            scheduleHours: z
+                .number()
+                .min(1)
+                .optional()
+                .describe('How often to check for drift (in hours). Used with set-schedule.'),
+        },
+        annotations: { title: 'Configure Drift Monitoring', destructiveHint: false },
+    }, safeTracked('configure_drift_monitoring', async (args) => handleConfigureDriftMonitoring(args)));
+    s.registerTool('drift_alert_rules', {
+        description: 'Manage alert rules for drift monitoring. Rules allow fine-grained thresholds per spec pattern.',
+        inputSchema: {
+            projectPath: z.string().describe('Absolute path to the project root.'),
+            action: z
+                .enum(['set-rules', 'list'])
+                .describe('Action to perform. Values: set-rules (replace all rules), list.'),
+            rules: z
+                .array(z.object({
+                name: z.string().describe('Human-readable rule name.'),
+                specIdPattern: z
+                    .string()
+                    .describe('Spec ID pattern to match (e.g. SPEC-* or SPEC-001).'),
+                thresholdOverride: z
+                    .number()
+                    .min(0)
+                    .max(100)
+                    .optional()
+                    .describe('Override threshold for matching specs.'),
+                enabled: z.boolean().describe('Whether this rule is active.'),
+            }))
+                .optional()
+                .describe('Array of rules to set. Required for set-rules action.'),
+        },
+        annotations: { title: 'Drift Alert Rules', destructiveHint: false },
+    }, safeTracked('drift_alert_rules', async (args) => handleDriftAlertRules(args)));
+    // ── Manage drift ─────────────────────────────────────────────────────────────
+    s.registerTool('manage_drift', {
+        description: 'Unified drift management tool. Drift = spec criteria with no matching code artifact. ' +
+            'NOT drift: style differences, naming conventions, test coverage gaps. ' +
+            'Actions: detect (find unmatched criteria), summary (current drift state), ' +
+            'resolve (auto-create follow-up specs for unmatched criteria), ' +
+            'watch (start/stop file-system monitoring).',
+        inputSchema: {
+            action: z
+                .enum(['detect', 'summary', 'resolve', 'watch'])
+                .describe('Drift management action. Values: detect (find drift), summary (current drift report), resolve (mark as resolved), watch (enable/disable monitoring)'),
+            projectPath: z
+                .string()
+                .min(1)
+                .max(4096)
+                .optional()
+                .describe('Absolute path to the project root directory. Required for all actions.'),
+            specId: z
+                .string()
+                .min(1)
+                .max(200)
+                .optional()
+                .describe('Specific spec to check drift for (e.g. "SPEC-042"). Used with detect and watch.'),
+            projectId: z
+                .string()
+                .optional()
+                .describe('Project ID (hash). Auto-derived from projectPath when not provided.'),
+            dryRun: z
+                .boolean()
+                .optional()
+                .describe('Preview what would be changed without writing files. Used with detect and resolve.'),
+            watchAction: z
+                .enum(['start', 'stop', 'status'])
+                .optional()
+                .describe('Sub-action for watch mode. Values: start (begin watching), stop (stop watcher), status (check state). Defaults to status.'),
+            specIds: z
+                .array(z.string())
+                .optional()
+                .describe('List of spec IDs to include in summary. If omitted, includes all specs.'),
+        },
+        annotations: { title: 'Manage Drift', destructiveHint: false },
+    }, safeTracked('manage_drift', async (args) => handleManageDrift(args)));
+    // Deprecated drift shims
+    s.registerTool('watch_spec_drift', {
+        description: '[DEPRECATED] Use manage_drift with action=watch instead. This shim delegates to manage_drift for backward compatibility.',
+        inputSchema: {
+            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
+            specId: z.string().min(1).describe('Spec ID to watch.'),
+            action: z.enum(['start', 'stop', 'status']).describe('start/stop/status for the watcher.'),
+        },
+        annotations: { title: '[Deprecated] Watch Spec Drift', destructiveHint: false },
+    }, safeTracked('watch_spec_drift', async (args) => {
+        const { projectPath, specId, action } = args;
+        return handleManageDrift({ action: 'watch', projectPath, specId, watchAction: action });
+    }));
+    s.registerTool('drift_summary_report', {
+        description: '[DEPRECATED] Use manage_drift with action=summary instead. This shim delegates to manage_drift for backward compatibility.',
+        inputSchema: {
+            projectPath: z.string().describe('Absolute path to the project root.'),
+            specIds: z.array(z.string()).optional().describe('Optional list of spec IDs.'),
+        },
+        annotations: { title: '[Deprecated] Drift Summary Report', readOnlyHint: true },
+    }, safeTracked('drift_summary_report', async (args) => {
+        const { projectPath, specIds } = args;
+        return handleManageDrift({ action: 'summary', projectPath, specIds });
+    }));
+    s.registerTool('resolve_drift_violations', {
+        description: '[DEPRECATED] Use manage_drift with action=resolve instead. This shim delegates to manage_drift for backward compatibility.',
+        inputSchema: {
+            projectPath: z.string().min(1).describe('Absolute path to the project root directory.'),
+            dryRun: z.boolean().optional().describe('Preview without writing files.'),
+        },
+        annotations: { title: '[Deprecated] Resolve Drift Violations', destructiveHint: false },
+    }, safeTracked('resolve_drift_violations', async (args) => {
+        const { projectPath, dryRun } = args;
+        return handleManageDrift({ action: 'resolve', projectPath, dryRun });
+    }));
+    // ── Code graph ───────────────────────────────────────────────────────────────
+    s.registerTool('configure_code_graph', {
+        description: 'Configure a Code Graph MCP provider for semantic code navigation. ' +
+            'Supports CodeGraphContext, Pathfinder, and Axon. ' +
+            'Each setup action adds the provider to .claude.json so it is available in Claude Code. ' +
+            'Actions: "setup-codegraph-context" | "setup-pathfinder" | "setup-axon" | "status".',
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            action: z
+                .enum(['setup-codegraph-context', 'setup-pathfinder', 'setup-axon', 'status'])
+                .describe('"setup-codegraph-context" adds the CodeGraphContext MCP server. "setup-pathfinder" adds Pathfinder. "setup-axon" adds Axon. "status" reports which providers are configured.'),
+        },
+        annotations: { title: 'Configure Code Graph Provider' },
+    }, safeLicensed('configure_code_graph', (args) => handleConfigureCodeGraph(args)));
+    s.registerTool('code_graph_status', {
+        description: 'Report which Code Graph MCP providers are configured in .claude.json. Returns providers list and the first active provider name.',
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+        },
+        annotations: { title: 'Code Graph Status', readOnlyHint: true },
+    }, safeLicensed('code_graph_status', (args) => handleCodeGraphStatus(args)));
+    // ── Estimation accuracy ───────────────────────────────────────────────────────
+    s.registerTool('record_actual', {
+        description: 'Record the actual hours spent on a completed spec to track estimation accuracy. ' +
+            'Use after marking a spec as done to close the feedback loop. ' +
+            'Data is stored per-project and used by estimation_accuracy_report and calibrate_estimates.',
+        inputSchema: {
+            ...projectIdSchema,
+            specId: z.string().min(1).describe('Spec ID to record actuals for (e.g. "SPEC-287").'),
+            actualHours: z
+                .number()
+                .min(0)
+                .describe('Total hours actually spent implementing this spec (dev + review combined).'),
+            notes: z
+                .string()
+                .max(1000)
+                .optional()
+                .describe('Optional notes explaining the deviation (e.g. "scope crept", "faster than expected").'),
+        },
+        annotations: { readOnlyHint: false },
+    }, safeLicensed('record_actual', withProject((args) => handleRecordActual(args))));
+    s.registerTool('calibrate_estimates', {
+        description: 'Recalculate estimation calibration factors based on accumulated historical actuals. ' +
+            'When historical data shows systematic over/underestimation (>20% avg deviation), ' +
+            'saves multipliers that the estimate tool uses to adjust future estimates automatically. ' +
+            'Overwrites previous calibration. Requires at least minSamples records per dimension.',
+        inputSchema: {
+            ...projectIdSchema,
+            minSamples: z
+                .number()
+                .int()
+                .min(1)
+                .optional()
+                .describe('Minimum number of actuals per scope/type before a calibration factor is applied (default: 3).'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true },
+    }, safeLicensed('calibrate_estimates', withProject((args) => handleCalibrateEstimates(args))));
+    // ── Workload distribution ────────────────────────────────────────────────────
+    s.registerTool('workload_distribution', {
+        description: 'Show current workload distribution across team members: WIP items, backlog (approved but not started), estimated hours, and imbalance warnings when one member has more than 2× the average WIP.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            weeks: z
+                .number()
+                .int()
+                .min(1)
+                .max(52)
+                .optional()
+                .describe('Unused for workload snapshot, accepted for API consistency.'),
+        },
+    }, safeTracked('workload_distribution', async (args) => handleWorkloadDistribution(args)));
+    // ── Spec scheduler ───────────────────────────────────────────────────────────
+    s.registerTool('simulate_parallel_execution', {
+        description: 'Simulate parallel execution of a set of specs across multiple agents. Returns a timeline with Gantt chart and critical path.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            specIds: z
+                .array(z.string())
+                .min(1)
+                .describe('List of spec IDs to include in the simulation.'),
+            numAgents: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .describe('Number of agents (parallel workers) to simulate.'),
+        },
+    }, safeTracked('simulate_parallel_execution', async (args) => handleSimulateParallelExecution(args)));
+    s.registerTool('critical_path_analyzer', {
+        description: 'Identify the critical path (longest chain of specs by estimated hours) for a project or a subset of specs.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            specIds: z
+                .array(z.string())
+                .optional()
+                .describe('Optional subset of spec IDs. Omit to analyze all project specs.'),
+        },
+    }, safeTracked('critical_path_analyzer', async (args) => handleCriticalPathAnalyzer(args)));
+    s.registerTool('parallel_efficiency_score', {
+        description: 'Calculate the parallel efficiency (utilization ratio) for executing a set of specs with N agents. Returns a score and interpretation.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            specIds: z
+                .array(z.string())
+                .min(1)
+                .describe('List of spec IDs to include in the efficiency calculation.'),
+            numAgents: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .describe('Number of agents to calculate efficiency for.'),
+        },
+    }, safeTracked('parallel_efficiency_score', async (args) => handleParallelEfficiencyScore(args)));
+    s.registerTool('optimize_spec_scheduling', {
+        description: 'Suggest an optimized scheduling order for specs to minimize agent idle time when executing in parallel.',
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            specIds: z
+                .array(z.string())
+                .optional()
+                .describe('Optional subset of spec IDs. Omit to optimize all project specs.'),
+            numAgents: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .optional()
+                .describe('Number of agents (default: 2).'),
+        },
+    }, safeTracked('optimize_spec_scheduling', async (args) => handleOptimizeSpecScheduling(args)));
+    // ── Crash shield ─────────────────────────────────────────────────────────────
+    s.registerTool('scan_crash_risks', {
+        description: 'Scan a project for crash risks: unhandled promise rejections, missing null checks, ' +
+            'uncaught exceptions, and other patterns that cause runtime crashes. ' +
+            'Returns a safety score (0–100) and a list of risks by severity. ' +
+            'Free tool — no license required.',
+        inputSchema: ScanCrashRisksSchema.shape,
+        annotations: { title: 'Scan Crash Risks', readOnlyHint: true },
+    }, safeTracked('scan_crash_risks', async (args) => handleScanCrashRisks(args)));
+    s.registerTool('fix_crash_risks', {
+        description: 'Auto-fix crash risks detected by scan_crash_risks. ' +
+            'Use dryRun:true first to preview what would change.',
+        inputSchema: FixCrashRisksSchema.shape,
+        annotations: { title: 'Fix Crash Risks', destructiveHint: true },
+    }, safeLicensed('fix_crash_risks', async (args) => handleFixCrashRisks(args)));
+    s.registerTool('configure_crash_rules', {
+        description: 'Configure custom crash risk detection rules for a project.',
+        inputSchema: ConfigureCrashRulesSchema.shape,
+        annotations: { title: 'Configure Crash Rules', destructiveHint: false },
+    }, safeLicensed('configure_crash_rules', async (args) => handleConfigureCrashRules(args)));
+    // ── Self healing ──────────────────────────────────────────────────────────────
+    s.registerTool('auto_fix_health', {
+        description: 'Auto-fix common health issues in a project (missing spec files, stale sessions, invalid JSON, etc.). Run after validate to repair issues automatically.',
+        inputSchema: {
+            projectPath: z
+                .string()
+                .min(1)
+                .max(4096)
+                .describe('Absolute path to the project root directory'),
+        },
+        annotations: { title: 'Auto-Fix Health Issues', destructiveHint: false },
+    }, safeLicensed('auto_fix_health', async (args) => {
+        const { projectPath, dryRun = false } = args;
+        const projectId = hashProjectPath(projectPath);
+        const result = await autoFixHealth(projectPath, projectId, dryRun);
+        const lines = [
+            dryRun ? '[DRY RUN] Auto-fix health report:' : 'Auto-fix health report:',
+            '',
+            `Fixed: ${result.fixedCount}`,
+            `Skipped (manual action required): ${result.skippedCount}`,
+            `Executed at: ${result.executedAt}`,
+        ];
+        if (result.fixes.length > 0) {
+            lines.push('', 'Fixes applied:');
+            for (const fix of result.fixes) {
+                lines.push(`  [${fix.success ? 'OK' : 'FAIL'}] ${fix.affectedItem}: ${fix.action}`);
+            }
+        }
+        if (result.skipped.length > 0) {
+            lines.push('', 'Skipped (requires manual action):');
+            for (const skip of result.skipped) {
+                lines.push(`  - ${skip.issue}: ${skip.reason}`);
+                for (const step of skip.manualSteps) {
+                    lines.push(`      → ${step}`);
+                }
+            }
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }));
+    s.registerTool('auto_fix_validation', {
+        description: 'Diagnose and auto-fix a specific validation failure. Supports failureType: typescript (tsc errors), lint (eslint --fix), test (test scaffolding), coverage (stub generation). Returns a detailed report of what was fixed and what still needs manual attention.',
+        inputSchema: {
+            projectPath: z
+                .string()
+                .min(1)
+                .max(4096)
+                .describe('Absolute path to the project root directory'),
+            specId: z
+                .string()
+                .min(1)
+                .max(200)
+                .describe('Spec ID associated with the failing validation (e.g. SPEC-474)'),
+            failureType: z
+                .enum(['typescript', 'lint', 'test', 'coverage'])
+                .describe('Type of validation failure. Values: typescript, lint, test, coverage.'),
+            failureDetails: z
+                .string()
+                .min(1)
+                .max(4096)
+                .describe('Full error output or description of the validation failure'),
+        },
+        annotations: { title: 'Auto-Fix Validation Failure', destructiveHint: false },
+    }, safeLicensed('auto_fix_validation', async (args) => handleAutoFixValidation(args)));
+    // ── run_healing_loop (migrated to skill, SPEC-658) ───────────────────────────
+    // Tool stays registered for backward compat; callers receive a deprecation notice.
+    registerFromEntries(s, [
+        makeDeprecationStub('run_healing_loop', '.claude/skills/spec-health.md', 'spec-health'),
+    ]);
+    // ── Auto remediation ──────────────────────────────────────────────────────────
+    s.registerTool('auto_remediate_compliance', {
+        description: 'For each compliance control gap, creates a stub spec so the team has a tracked work item. ' +
+            'Already-covered controls are reported. Partially-covered controls list manual actions needed. ' +
+            'Use dryRun=true to preview without creating any files.',
+        inputSchema: {
+            projectPath: z
+                .string()
+                .min(1)
+                .max(4096)
+                .describe('Absolute path to the project root directory'),
+            framework: z
+                .enum(['SOC2', 'GDPR', 'HIPAA', 'ISO27001'])
+                .describe('Compliance framework to remediate: SOC2=service org controls, GDPR=EU data privacy, HIPAA=US health data, ISO27001=security management'),
+            dryRun: z
+                .boolean()
+                .optional()
+                .describe('When true, report what would be created without writing any files (default: false)'),
+        },
+        annotations: { title: 'Auto Remediate Compliance Gaps' },
+    }, safeLicensed('auto_remediate_compliance', async (args) => {
+        const { projectPath, framework, dryRun = false, } = args;
+        const projectId = hashProjectPath(projectPath);
+        const result = await autoRemediateCompliance(projectPath, projectId, framework, dryRun);
+        const lines = [
+            dryRun
+                ? `[DRY RUN] Compliance remediation for ${result.framework}:`
+                : `Compliance remediation for ${result.framework}:`,
+            '',
+            `Specs created: ${result.createdSpecs.length}`,
+            `Controls already covered: ${result.alreadyCovered.length}`,
+            `Manual actions required: ${result.manualActionRequired.length}`,
+        ];
+        if (result.createdSpecs.length > 0) {
+            lines.push('', 'Specs created:');
+            for (const id of result.createdSpecs) {
+                lines.push(`  + ${id}`);
+            }
+        }
+        if (result.alreadyCovered.length > 0) {
+            lines.push('', 'Already covered controls:');
+            for (const ctrl of result.alreadyCovered) {
+                lines.push(`  ✓ ${ctrl}`);
+            }
+        }
+        if (result.manualActionRequired.length > 0) {
+            lines.push('', 'Manual actions required:');
+            for (const action of result.manualActionRequired) {
+                lines.push(`  - ${action.control}: ${action.description}`);
+                for (const step of action.steps) {
+                    lines.push(`      → ${step}`);
+                }
+            }
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }));
+    // ── Auto promoter ─────────────────────────────────────────────────────────────
+    s.registerTool('configure_auto_promotion', {
+        description: 'Configure auto-promotion settings for a project. ' +
+            'When enabled, specs that reach the confidence threshold are eligible for automatic status promotion. ' +
+            'High-risk specs are never auto-promoted regardless of settings.',
+        inputSchema: {
+            projectPath: z.string().describe('Absolute path to the project directory.'),
+            enabled: z
+                .boolean()
+                .optional()
+                .describe('Enable or disable auto-promotion for the project.'),
+            threshold: z
+                .number()
+                .min(0)
+                .max(100)
+                .optional()
+                .describe('Confidence score threshold (0-100). Specs below this are not auto-promoted. Default: 85.'),
+            maxRisk: z
+                .enum(['low', 'medium'])
+                .optional()
+                .describe('Maximum risk level allowed for auto-promotion. Valid values: "low" (only low-risk specs), "medium" (low and medium). High-risk specs are never auto-promoted.'),
+        },
+        annotations: { title: 'Configure Auto Promotion' },
+    }, safeLicensed('configure_auto_promotion', async (args) => handleConfigureAutoPromotion(args)));
+    s.registerTool('check_auto_promotion', {
+        description: 'Check whether a spec is eligible for auto-promotion by computing its confidence score. Returns the score breakdown (readiness, risk penalty, dependency bonus) and eligibility verdict.',
+        inputSchema: {
+            projectPath: z.string().describe('Absolute path to the project directory.'),
+            specId: z.string().describe('Spec ID to evaluate (e.g., "SPEC-042").'),
+        },
+        annotations: { title: 'Check Auto Promotion', readOnlyHint: true },
+    }, safeLicensed('check_auto_promotion', async (args) => handleCheckAutoPromotion(args)));
+    // ── Multi-teammate review (SPEC-593) ─────────────────────────────────────────
+    registerMultiTeammateReviewTool(s);
+    // ── Observatory insights (SPEC-572) ──────────────────────────────────────────
+    s.registerTool('observatory_insights', {
+        description: 'Planu Observatory: derive cross-project aggregated telemetry insights. ' +
+            'Local mode (always available): computes patterns from your own spec actuals history — ' +
+            'estimation bias, velocity averages, per-scope accuracy. ' +
+            'Remote mode (opt-in via configure_telemetry enableObservatory=true): fetches community ' +
+            'patterns from planu.dev/api/observatory with a 24-hour cache. ' +
+            'PRIVACY: only aggregate numbers are computed — no file paths, spec titles, or personal data.',
+        annotations: { title: 'Observatory Insights', readOnlyHint: true },
+        inputSchema: {
+            projectPath: z
+                .string()
+                .min(1)
+                .max(4096)
+                .optional()
+                .describe('Absolute path to a specific project. Omit to analyze all registered projects.'),
+            includeGlobal: z
+                .boolean()
+                .optional()
+                .describe('When true, also fetch community insights from planu.dev (requires enableObservatory=true in telemetry config). ' +
+                'Results are cached for 24 hours. Falls back to local-only on network failure.'),
+        },
+    }, safeTracked('observatory_insights', async (args) => handleObservatoryInsights(args)));
+    // ── Code duplication detection (SPEC-970) ──────────────────────────────────
+    s.registerTool('detect_duplication', {
+        description: 'Scan a project for code duplication. Uses token-based sliding window detection ' +
+            'to find duplicate blocks of code across files. Returns clusters with file locations, ' +
+            'line counts, severity, and extraction suggestions.',
+        annotations: { title: 'Detect Code Duplication', readOnlyHint: true },
+        inputSchema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
+            minLines: z
+                .number()
+                .int()
+                .min(2)
+                .max(100)
+                .optional()
+                .default(5)
+                .describe('Minimum number of consecutive lines to consider a duplicate (default: 5).'),
+            exclude: z
+                .array(z.string())
+                .optional()
+                .describe('Additional glob patterns to exclude beyond the defaults.'),
+            languages: z
+                .array(z.enum(['typescript', 'javascript']))
+                .optional()
+                .describe('Languages to scan. Values: typescript, javascript. Defaults to both.'),
+        },
+    }, safeTracked('detect_duplication', async (args) => handleDetectDuplication(args)));
+}
+//# sourceMappingURL=group-analysis-monitoring.js.map