@planu/cli 4.1.0 → 4.1.2

package/dist/tools/tool-registry/group-session-knowledge.js

@@ -1,1416 +0,0 @@
-/* eslint-disable max-lines -- thematic registry group consolidated by SPEC refactor-phase3 (commit aafeea60); each block is a declarative tool registration ~20 lines, split would re-create the ~120 register-*.ts files this phase intentionally collapsed */
-// tools/tool-registry/group-session-knowledge.ts — Group E: Session & Knowledge tools
-// Consolidates: session-tools, checkpoint-tool, checkpoints, autopilot-tools, autopilot,
-// learning, lessons, knowledge-base, backlog, agent, agent-squad, orchestrator,
-// delete, delete-first, legacy, elicitation, context, context-manager, scope
-// (Phase 3 registry refactor — inline, no delegation)
-import { z } from 'zod';
-import { safeLicensed, safeTracked } from '../safe-handler.js';
-import { projectIdSchema, withProject } from '../tool-registry-helpers.js';
-// ── Session tools (register-session-tools.ts) ────────────────────────────────
-import { SessionHandoffSchema, RestoreSessionSchema, ListSessionsSchema, ExportSessionSchema, } from '../schemas/session.js';
-import { handleSessionHandoff } from '../session-handoff.js';
-import { handleRestoreSession } from '../restore-session.js';
-import { handleListSessions } from '../list-sessions.js';
-import { handleExportSession } from '../export-session.js';
-// ── Session checkpoint (register-checkpoint-tool.ts) ─────────────────────────
-import { handleSessionCheckpoint } from '../checkpoint-handler.js';
-// ── Approval checkpoints (register-checkpoints.ts) ───────────────────────────
-import { handleConfigureCheckpointPolicy } from '../checkpoint/configure-policy-handler.js';
-import { handleRequireCheckpoint } from '../checkpoint/require-checkpoint-handler.js';
-import { handleApproveCheckpoint } from '../checkpoint/approve-checkpoint-handler.js';
-import { handleRejectCheckpoint } from '../checkpoint/reject-checkpoint-handler.js';
-import { handleListPendingCheckpoints } from '../checkpoint/list-checkpoints-handler.js';
-// ── Autopilot audit (register-autopilot-tools.ts) ────────────────────────────
-import { handleAutopilotAudit } from '../autopilot-audit.js';
-// ── Configure autopilot (register-autopilot.ts) ───────────────────────────────
-import { loadAutopilotConfig, saveAutopilotConfig, getAutopilotStatus, } from '../../engine/autopilot/action-executor.js';
-// ── Learning tools (register-learning-tools.ts) ───────────────────────────────
-import { t } from '../../i18n/index.js';
-import { handleCaptureLearning } from '../capture-learning.js';
-// ── Lessons tools (register-lessons-tools.ts) ────────────────────────────────
-import { handleLogLesson, handleListLessons } from '../lessons-handler.js';
-// ── Knowledge base (register-knowledge-base-tools.ts) ────────────────────────
-import { handleSemanticDecisionSearch, handleSimilarProblemsFinder, handleExtractLessonsFromText, handleKnowledgeGapDetector, handleKnowledgeSummary, } from '../knowledge-base-handler.js';
-// ── Backlog tools (register-backlog-tools.ts) ─────────────────────────────────
-import { handleCaptureIdea } from '../capture-idea-handler.js';
-import { handleListBacklog } from '../list-backlog-handler.js';
-import { handlePromoteIdea } from '../promote-idea-handler.js';
-import { handleDiscardIdea } from '../discard-idea-handler.js';
-// ── Agent tools (register-agent-tools.ts) ────────────────────────────────────
-import { handleOrchestrateAgents } from '../orchestrate-agents.js';
-// ── Agent squad tools (register-agent-squad-tools.ts) ────────────────────────
-// NOTE: registerAgentSquadHandlers (event bus) is called from index.ts — do NOT inline here.
-import { getSquadConfig, setAgentEnabled, getSpecRunHistory, getSquadRuns, } from '../../storage/agent-squad-store.js';
-import { hashProjectPath } from '../../storage/base-store.js';
-// ── Orchestrator tools (register-orchestrator-tools.ts) ───────────────────────
-import { handleOrchestrateRuntime } from '../orchestrate-runtime.js';
-import { handleAgentSwarmStatus } from '../agent-swarm-status.js';
-// ── Delete tools (register-delete-tools.ts) ───────────────────────────────────
-import { TrashActionEnum } from '../schemas/index.js';
-import { handleDeleteSpec } from '../delete-spec.js';
-import { handleDeleteProject } from '../delete-project.js';
-import { handleDeletePattern } from '../delete-pattern.js';
-import { handleDeleteDecision } from '../delete-decision.js';
-import { handleManageTrash } from '../manage-trash.js';
-// ── Delete-first tools (register-delete-first-tools.ts) ───────────────────────
-import { handleSuggestDeletions, SuggestDeletionsInputSchema, } from '../delete-first/suggest-deletions.js';
-import { handleSustainabilityScore, SustainabilityScoreInputSchema, } from '../delete-first/sustainability-score.js';
-import { handleSimplicityMetric, SimplicityMetricInputSchema, } from '../delete-first/simplicity-metric.js';
-// ── Legacy tools (register-legacy-tools.ts) ───────────────────────────────────
-import { handleCharacterizeLegacyCode, CharacterizeLegacyCodeInputSchema, } from '../legacy/characterize-legacy-code.js';
-import { handleDetectHyrumRisks, DetectHyrumRisksInputSchema, } from '../legacy/detect-hyrum-risks.js';
-import { handleSeamsDetector, SeamsDetectorInputSchema } from '../legacy/seams-detector.js';
-import { handleRefactorWithSafetyNet, RefactorWithSafetyNetInputSchema, } from '../legacy/refactor-with-safety-net.js';
-// ── Elicitation tools (register-elicitation-tools.ts) ────────────────────────
-import { handleElicitRequirements } from '../elicit-requirements-handler.js';
-// ── Context tools (register-context-tools.ts) ────────────────────────────────
-import { handleRequestContext, handleContributeContext } from '../contribute-context.js';
-// ── Context manager tools (register-context-manager-tools.ts) ────────────────
-import { handleContextWindowStatus, handleOptimizeContext, handleContextBudgetConfig, handleArchiveSpecContext, handleCompressSpecHistory, handleRestoreArchivedContext, } from '../context-manager-handler.js';
-// ── Scope tools (register-scope-tools.ts) ────────────────────────────────────
-import { handleManageScope } from '../manage-scope.js';
-import { handleDetectContradictions } from '../detect-contradictions.js';
-// ---------------------------------------------------------------------------
-// Shared sub-schemas
-// ---------------------------------------------------------------------------
-const CATEGORY_ENUM = z.enum([
-    'estimation',
-    'testing',
-    'architecture',
-    'security',
-    'performance',
-    'ux',
-    'process',
-    'other',
-]);
-const SEVERITY_ENUM = z.enum(['low', 'medium', 'high']);
-const STRATEGY_DESCRIBE = 'Archiving strategy. Valid values: archive-oldest | archive-done | compress-history | manual';
-const taskDescriptionSchema = z.object({
-    id: z.string().max(500).describe('Unique task identifier'),
-    description: z.string().max(10_000).describe('Natural-language task description'),
-    requirements: z.array(z.string().max(500)).max(100).describe('Capabilities required'),
-    files: z.array(z.string().max(4096)).max(1000).describe('File paths this task works with'),
-    dependencies: z.array(z.string().max(500)).max(100).describe('Task IDs that must complete first'),
-    priority: z.number().min(0).describe('Priority (higher = more important)'),
-    critical: z.boolean().describe('If true, orchestration fails if this task fails'),
-});
-const agentConfigSchema = z.object({
-    id: z.string().max(500).describe('Unique agent identifier'),
-    command: z.string().max(4096).describe('CLI command to spawn (e.g. "claude", "python")'),
-    args: z.array(z.string().max(4096)).max(100).describe('Command arguments'),
-    capabilities: z.array(z.string().max(500)).max(100).describe('Agent capabilities'),
-    modelTier: z
-        .enum(['haiku', 'sonnet', 'opus'])
-        .optional()
-        .describe('Model tier: haiku | sonnet | opus'),
-    workDir: z.string().max(4096).optional().describe('Working directory for the agent'),
-});
-// ---------------------------------------------------------------------------
-// Main export
-// ---------------------------------------------------------------------------
-// eslint-disable-next-line max-lines-per-function -- registration catalog: one block per tool, each ~20 lines
-export function registerSessionKnowledgeGroupTools(s) {
-    // ── Session tools ──────────────────────────────────────────────────────────
-    s.registerTool('session_handoff', {
-        description: 'Generate a compact (≤200-token) session handoff packet to paste at the start of a fresh Claude session. ' +
-            'Shows active spec + pending criteria, next queued spec, git branch state, and the next action step. ' +
-            'Use before closing a session that has been inactive for ~1 hour to avoid expensive context resumption.',
-        inputSchema: SessionHandoffSchema,
-        annotations: { readOnlyHint: true },
-    }, safeTracked('session_handoff', async (args) => handleSessionHandoff(args)));
-    s.registerTool('restore_session', {
-        description: 'Restore a previous session to recover context (active specs, decisions, modified files). ' +
-            'If no sessionId is provided, restores the most recent session. ' +
-            'Returns context summary, active specs, and recent decisions.',
-        inputSchema: RestoreSessionSchema,
-        annotations: { readOnlyHint: true },
-    }, safeLicensed('restore_session', async (args) => handleRestoreSession(args)));
-    s.registerTool('list_sessions', {
-        description: 'List recent sessions for a project with summary info. ' +
-            'Returns session IDs, timestamps, context summaries, and tool call counts. ' +
-            'Ordered by most recent first.',
-        inputSchema: ListSessionsSchema,
-        annotations: { readOnlyHint: true },
-    }, safeLicensed('list_sessions', async (args) => handleListSessions(args)));
-    s.registerTool('export_session', {
-        description: 'Export a session as markdown or JSON for handoff between agents or documentation. ' +
-            'Markdown format includes sections for Summary, Specs, Decisions, Files, and Metadata. ' +
-            'If no sessionId is provided, exports the most recent session.',
-        inputSchema: ExportSessionSchema,
-        annotations: { readOnlyHint: true },
-    }, safeLicensed('export_session', async (args) => handleExportSession(args)));
-    // ── Session checkpoint ─────────────────────────────────────────────────────
-    s.registerTool('session_checkpoint', {
-        description: 'Save a session checkpoint with current context (active specs, decisions, staged files, next steps). ' +
-            'Returns a compact handoff block to paste in the next session for seamless context recovery. ' +
-            'State is stored in planu/session-state.json and expires after 24 hours.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root'),
-            projectId: z
-                .string()
-                .min(1)
-                .max(500)
-                .describe('Project ID (hash). Use the ID returned by init_project.'),
-            decisions: z
-                .array(z.string().max(500))
-                .max(20)
-                .optional()
-                .describe('Key decisions made this session (up to 5 stored; provide most important first)'),
-            nextSteps: z
-                .array(z.string().max(500))
-                .max(20)
-                .optional()
-                .describe('Pending next steps to resume in the next session'),
-        },
-        annotations: { readOnlyHint: false },
-    }, safeTracked('session_checkpoint', async (args) => handleSessionCheckpoint(args)));
-    // ── Approval checkpoints ───────────────────────────────────────────────────
-    s.registerTool('configure_checkpoint_policy', {
-        description: 'Configure approval checkpoints that block spec status transitions until a designated role approves. ' +
-            'Apply a built-in preset (strict/balanced/relaxed) or define custom per-transition policies. ' +
-            'This implements the Judge gate in Planner→Worker→Judge governance.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            preset: z
-                .enum(['strict', 'balanced', 'relaxed'])
-                .optional()
-                .describe('Policy preset: strict=all transitions need approval (draft->review, review->approved, approved->implementing, implementing->done), ' +
-                'balanced=key transitions only (review->approved, implementing->done), ' +
-                'relaxed=only completion needs approval (implementing->done).'),
-            policies: z
-                .array(z.object({
-                transition: z
-                    .string()
-                    .min(1)
-                    .describe('Transition to gate, e.g. "review->approved". Valid statuses: draft, review, approved, implementing, done, discarded.'),
-                requiredRole: z
-                    .string()
-                    .min(1)
-                    .describe('Role that must approve: developer, tech_lead, qa, product_owner, admin.'),
-                description: z
-                    .string()
-                    .min(1)
-                    .describe('Human-readable explanation of why this checkpoint exists.'),
-                autoApproveAfterHours: z
-                    .number()
-                    .positive()
-                    .optional()
-                    .describe('Hours before the checkpoint auto-approves if no action is taken.'),
-            }))
-                .optional()
-                .describe('Custom policies (used when preset is not set). Replaces all existing policies for the project.'),
-        },
-        annotations: { title: 'Configure Checkpoint Policy', destructiveHint: false },
-    }, safeTracked('configure_checkpoint_policy', (args) => handleConfigureCheckpointPolicy(args)));
-    s.registerTool('require_checkpoint', {
-        description: 'Create a pending checkpoint that blocks a specific spec status transition. ' +
-            'Returns the checkpoint ID and instructions on who needs to approve it. ' +
-            'The checkpoint must be approved via approve_checkpoint before the transition can proceed.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            specId: z.string().min(1).max(500).describe('Spec ID to block, e.g. SPEC-042.'),
-            transition: z
-                .string()
-                .min(1)
-                .describe('Status transition to block, e.g. "review->approved". Must match a configured policy.'),
-            requestedBy: z
-                .string()
-                .optional()
-                .describe('Identifier of who is requesting the checkpoint (defaults to "system").'),
-        },
-        annotations: { title: 'Require Checkpoint', destructiveHint: false },
-    }, safeTracked('require_checkpoint', (args) => handleRequireCheckpoint(args)));
-    s.registerTool('approve_checkpoint', {
-        description: 'Approve a pending checkpoint, unblocking the associated spec status transition. ' +
-            'Returns confirmation and next steps for the spec.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            checkpointId: z
-                .string()
-                .min(1)
-                .describe('ID of the checkpoint to approve (returned by require_checkpoint).'),
-            approvedBy: z
-                .string()
-                .optional()
-                .describe('Identifier of the approver (defaults to "anonymous").'),
-        },
-        annotations: { title: 'Approve Checkpoint', destructiveHint: false },
-    }, safeTracked('approve_checkpoint', (args) => handleApproveCheckpoint(args)));
-    s.registerTool('reject_checkpoint', {
-        description: 'Reject a pending checkpoint, blocking the associated spec status transition. ' +
-            'A rejection reason is required. The spec stays in its current status.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            checkpointId: z
-                .string()
-                .min(1)
-                .describe('ID of the checkpoint to reject (returned by require_checkpoint).'),
-            rejectedBy: z
-                .string()
-                .optional()
-                .describe('Identifier of the reviewer rejecting (defaults to "anonymous").'),
-            reason: z
-                .string()
-                .min(1)
-                .describe('Mandatory explanation of why the checkpoint was rejected.'),
-        },
-        annotations: { title: 'Reject Checkpoint', destructiveHint: false },
-    }, safeTracked('reject_checkpoint', (args) => handleRejectCheckpoint(args)));
-    s.registerTool('list_pending_checkpoints', {
-        description: 'List all pending approval checkpoints for a project. ' +
-            'Optionally filter by required role to see only checkpoints relevant to you. ' +
-            'Returns spec ID, transition being blocked, required role, and requester.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            role: z
-                .string()
-                .optional()
-                .describe('Filter by required role: developer, tech_lead, qa, product_owner, admin. Omit to list all pending checkpoints.'),
-        },
-        annotations: { title: 'List Pending Checkpoints', readOnlyHint: true },
-    }, safeTracked('list_pending_checkpoints', (args) => handleListPendingCheckpoints(args)));
-    // ── Autopilot audit ────────────────────────────────────────────────────────
-    s.registerTool('autopilot_audit', {
-        description: 'Query the persistent audit log of all autopilot cascade actions. Returns timestamped entries for every action automatically triggered by Planu tools (e.g. migrateAllSpecsToLean, cleanPlanuRoot, regenerateSpecSummaryHtml).',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            trigger: z
-                .string()
-                .max(200)
-                .optional()
-                .describe('Filter by the tool that triggered the action. Example: "list_specs", "update_status(done)".'),
-            action: z
-                .string()
-                .max(200)
-                .optional()
-                .describe('Filter by action name. Example: "migrateAllSpecsToLean", "cleanPlanuRoot", "regenerateSpecSummaryHtml".'),
-            status: z
-                .enum(['ok', 'fail', 'timeout', 'skipped'])
-                .optional()
-                .describe('Filter by result status. Values: ok — succeeded, fail — threw an error, timeout — exceeded time limit, skipped — precondition not met.'),
-            since: z
-                .string()
-                .max(100)
-                .optional()
-                .describe('ISO 8601 timestamp. Only return entries at or after this time. Example: "2026-04-01T00:00:00.000Z".'),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(500)
-                .optional()
-                .describe('Maximum number of entries to return (default: 50, max: 500).'),
-        },
-        annotations: { readOnlyHint: true },
-    }, safeLicensed('autopilot_audit', async (args) => handleAutopilotAudit(args)));
-    // ── Configure autopilot ────────────────────────────────────────────────────
-    s.registerTool('configure_autopilot', {
-        description: 'Enable/disable individual autopilot triggers, set thresholds, toggle complete-loop flags (auto-branch, auto-scaffold-TDD, auto-PR), or view current autopilot status. Autopilot auto-triggers tools like validate_criteria_quality, tdd_scaffold, and resolve_drift_violations at the right moments in the spec lifecycle.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            action: z
-                .enum(['enable', 'disable', 'status', 'set-threshold'])
-                .describe('Action to perform. Values: enable — activate a trigger rule or complete-loop flag, disable — deactivate a trigger rule or complete-loop flag, status — show all rules and their state, set-threshold — update numeric threshold for a conditional rule or the auto-merge score gate.'),
-            triggerId: z
-                .string()
-                .max(200)
-                .optional()
-                .describe('ID of the trigger rule to enable/disable/configure. Example: "post-create:validate_criteria_quality". For complete-loop flags (SPEC-569) use: "autoCreateBranch", "autoScaffoldTdd", "autoCreatePr", or "autoMergeThreshold". Required for enable/disable/set-threshold.'),
-            threshold: z
-                .number()
-                .optional()
-                .describe('Threshold value for set-threshold action. For hour-based triggers: minimum estimated hours. For drift triggers: minimum drift score (0-1). For autoMergeThreshold: minimum validate score (0-100) required to auto-create a PR (default 85).'),
-            autoCreateBranch: z
-                .boolean()
-                .optional()
-                .describe('SPEC-569: When true, update_status(approved) auto-creates a feature branch for the spec. Fire-and-forget.'),
-            autoScaffoldTdd: z
-                .boolean()
-                .optional()
-                .describe('SPEC-569: When true, update_status(approved) auto-generates TDD test scaffolding. Default false. Fire-and-forget.'),
-            autoCreatePr: z
-                .boolean()
-                .optional()
-                .describe('SPEC-569: When true, update_status(done) auto-creates a PR once validate score meets autoMergeThreshold. Default false. Fire-and-forget.'),
-            autoMergeThreshold: z
-                .number()
-                .min(0)
-                .max(100)
-                .optional()
-                .describe('SPEC-569: Minimum validate score (0-100) required to auto-create a PR. Default 85. Only used when autoCreatePr is true.'),
-        },
-        annotations: { readOnlyHint: false },
-    }, safeLicensed('configure_autopilot', async (args) => {
-        // SPEC-569: Allow bulk-setting complete-loop flags regardless of action,
-        // so callers can toggle them with a single tool invocation.
-        const completeLoopTouched = args.autoCreateBranch !== undefined ||
-            args.autoScaffoldTdd !== undefined ||
-            args.autoCreatePr !== undefined ||
-            args.autoMergeThreshold !== undefined;
-        if (completeLoopTouched) {
-            const config = await loadAutopilotConfig(args.projectPath);
-            if (args.autoCreateBranch !== undefined) {
-                config.autoCreateBranch = args.autoCreateBranch;
-            }
-            if (args.autoScaffoldTdd !== undefined) {
-                config.autoScaffoldTdd = args.autoScaffoldTdd;
-            }
-            if (args.autoCreatePr !== undefined) {
-                config.autoCreatePr = args.autoCreatePr;
-            }
-            if (args.autoMergeThreshold !== undefined) {
-                config.autoMergeThreshold = args.autoMergeThreshold;
-            }
-            await saveAutopilotConfig(args.projectPath, config);
-            const summary = [
-                args.autoCreateBranch !== undefined
-                    ? `autoCreateBranch=${String(args.autoCreateBranch)}`
-                    : null,
-                args.autoScaffoldTdd !== undefined
-                    ? `autoScaffoldTdd=${String(args.autoScaffoldTdd)}`
-                    : null,
-                args.autoCreatePr !== undefined ? `autoCreatePr=${String(args.autoCreatePr)}` : null,
-                args.autoMergeThreshold !== undefined
-                    ? `autoMergeThreshold=${String(args.autoMergeThreshold)}`
-                    : null,
-            ]
-                .filter((entry) => entry !== null)
-                .join(', ');
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ Autopilot complete-loop updated: ${summary}.`,
-                    },
-                ],
-            };
-        }
-        if (args.action === 'status') {
-            const status = await getAutopilotStatus(args.projectPath);
-            const lines = status.rules.map((r) => `${r.enabled ? '✅' : '⬜'} \`${r.id}\` — ${r.description}`);
-            const config = await loadAutopilotConfig(args.projectPath);
-            const completeLoop = [
-                `${config.autoCreateBranch === true ? '✅' : '⬜'} autoCreateBranch`,
-                `${config.autoScaffoldTdd === true ? '✅' : '⬜'} autoScaffoldTdd`,
-                `${config.autoCreatePr === true ? '✅' : '⬜'} autoCreatePr (threshold: ${String(config.autoMergeThreshold ?? 85)})`,
-            ].join('\n');
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `## Autopilot Status\n\n**${status.enabledRules}/${status.totalRules} rules enabled**\n\n${lines.join('\n')}\n\n### Complete Loop (SPEC-569)\n\n${completeLoop}`,
-                    },
-                ],
-            };
-        }
-        if (!args.triggerId) {
-            return {
-                isError: true,
-                content: [
-                    {
-                        type: 'text',
-                        text: 'triggerId is required for enable/disable/set-threshold actions.',
-                    },
-                ],
-            };
-        }
-        const config = await loadAutopilotConfig(args.projectPath);
-        // SPEC-569: Allow toggling complete-loop flags via triggerId for UX symmetry.
-        if (args.triggerId === 'autoCreateBranch') {
-            config.autoCreateBranch = args.action === 'enable';
-            await saveAutopilotConfig(args.projectPath, config);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ autoCreateBranch ${args.action === 'enable' ? 'enabled' : 'disabled'}.`,
-                    },
-                ],
-            };
-        }
-        if (args.triggerId === 'autoScaffoldTdd') {
-            config.autoScaffoldTdd = args.action === 'enable';
-            await saveAutopilotConfig(args.projectPath, config);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ autoScaffoldTdd ${args.action === 'enable' ? 'enabled' : 'disabled'}.`,
-                    },
-                ],
-            };
-        }
-        if (args.triggerId === 'autoCreatePr') {
-            config.autoCreatePr = args.action === 'enable';
-            await saveAutopilotConfig(args.projectPath, config);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ autoCreatePr ${args.action === 'enable' ? 'enabled' : 'disabled'}.`,
-                    },
-                ],
-            };
-        }
-        if (args.triggerId === 'autoMergeThreshold' && args.action === 'set-threshold') {
-            if (args.threshold === undefined) {
-                return {
-                    isError: true,
-                    content: [
-                        {
-                            type: 'text',
-                            text: 'threshold is required when setting autoMergeThreshold.',
-                        },
-                    ],
-                };
-            }
-            config.autoMergeThreshold = args.threshold;
-            await saveAutopilotConfig(args.projectPath, config);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ autoMergeThreshold set to ${String(args.threshold)}.`,
-                    },
-                ],
-            };
-        }
-        if (args.action === 'enable') {
-            config.rules[args.triggerId] = { ...(config.rules[args.triggerId] ?? {}), enabled: true };
-        }
-        else if (args.action === 'disable') {
-            config.rules[args.triggerId] = {
-                ...(config.rules[args.triggerId] ?? {}),
-                enabled: false,
-            };
-        }
-        else if (args.action === 'set-threshold' && args.threshold !== undefined) {
-            config.rules[args.triggerId] = {
-                ...(config.rules[args.triggerId] ?? { enabled: true }),
-                threshold: args.threshold,
-            };
-        }
-        await saveAutopilotConfig(args.projectPath, config);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Autopilot rule \`${args.triggerId}\` updated (action: ${args.action}).`,
-                },
-            ],
-        };
-    }));
-    // ── Learning tools ─────────────────────────────────────────────────────────
-    s.registerTool('capture_learning', {
-        description: t('tools.capture_learning.description'),
-        annotations: { readOnlyHint: false },
-        inputSchema: {
-            description: z
-                .string()
-                .max(10_000)
-                .describe('Natural language description of the pattern or improvement discovered'),
-            specId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Target spec ID override (optional — auto-routed if omitted)'),
-            subcommand: z
-                .enum(['lesson'])
-                .optional()
-                .describe('lesson: capture a lesson into lessons-learned registry'),
-            lessonType: z
-                .enum([
-                'bug-pattern',
-                'arch-mismatch',
-                'estimation-error',
-                'tool-limitation',
-                'test-complexity',
-            ])
-                .optional()
-                .describe('Lesson type (required when subcommand is lesson)'),
-            tags: z
-                .array(z.string().max(500))
-                .max(100)
-                .optional()
-                .describe('Search tags for the lesson (optional)'),
-        },
-    }, safeLicensed('capture_learning', async (args) => handleCaptureLearning(args)));
-    // ── Lessons tools ──────────────────────────────────────────────────────────
-    s.registerTool('log_lesson', {
-        description: 'Log a lesson learned from a spec or project experience. ' +
-            'Captures what went wrong (or right), the category, severity, and how to prevent it next time. ' +
-            'Use after bugs, rollbacks, or effort >50% over estimate.',
-        inputSchema: {
-            projectId: z.string().max(500).optional().describe('Project ID hash. Prefer projectPath.'),
-            projectPath: z
-                .string()
-                .max(4096)
-                .optional()
-                .describe('Absolute path to project root. Derives projectId automatically.'),
-            specId: z
-                .string()
-                .optional()
-                .describe('Optional spec ID this lesson relates to (e.g. "SPEC-042").'),
-            category: CATEGORY_ENUM.describe('Category: estimation | testing | architecture | security | performance | ux | process | other'),
-            severity: SEVERITY_ENUM.describe('Severity: low | medium | high'),
-            title: z.string().min(3).max(200).describe('Short title of the lesson.'),
-            description: z.string().min(5).max(2000).describe('What went wrong or what was learned.'),
-            prevention: z.string().min(5).max(1000).describe('What to do differently next time.'),
-            tags: z
-                .array(z.string().max(50))
-                .max(10)
-                .optional()
-                .describe('Optional tags for searching (e.g. ["async", "zod"]).'),
-        },
-        annotations: { readOnlyHint: false },
-    }, safeLicensed('log_lesson', async (args) => handleLogLesson(args)));
-    s.registerTool('list_lessons', {
-        description: 'List lessons learned for a project. ' +
-            'Optionally filter by category, severity, or spec ID. ' +
-            'Returns matching lessons plus frequency stats by category to surface recurring patterns.',
-        inputSchema: {
-            projectId: z.string().max(500).optional().describe('Project ID hash. Prefer projectPath.'),
-            projectPath: z
-                .string()
-                .max(4096)
-                .optional()
-                .describe('Absolute path to project root. Derives projectId automatically.'),
-            category: CATEGORY_ENUM.optional().describe('Filter by category: estimation | testing | architecture | security | performance | ux | process | other'),
-            severity: SEVERITY_ENUM.optional().describe('Filter by severity: low | medium | high'),
-            specId: z.string().optional().describe('Filter by spec ID (e.g. "SPEC-042").'),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(100)
-                .optional()
-                .default(20)
-                .describe('Max results to return (default 20, max 100).'),
-        },
-        annotations: { readOnlyHint: true },
-    }, safeLicensed('list_lessons', async (args) => handleListLessons(args)));
-    // ── Knowledge base ─────────────────────────────────────────────────────────
-    s.registerTool('semantic_decision_search', {
-        description: 'Search project decisions using TF-IDF relevance scoring. Returns decisions ranked by relevance to the query.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            query: z.string().min(1).max(500).describe('Search query to find relevant decisions.'),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(20)
-                .optional()
-                .describe('Maximum number of results to return (default: 5).'),
-        },
-    }, safeTracked('semantic_decision_search', async (args) => handleSemanticDecisionSearch(args)));
-    s.registerTool('similar_problems_finder', {
-        description: 'Find specs with similar titles and descriptions to a given query or problem statement. Uses keyword overlap scoring.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            query: z
-                .string()
-                .min(1)
-                .max(500)
-                .describe('Problem description or spec text to match against.'),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(20)
-                .optional()
-                .describe('Maximum number of results to return (default: 5).'),
-        },
-    }, safeTracked('similar_problems_finder', async (args) => handleSimilarProblemsFinder(args)));
-    s.registerTool('extract_lessons_from_text', {
-        description: 'Extract lesson-like phrases from free-form text (retrospectives, post-mortems). Detects patterns like "we learned that", "always", "never", "avoid".',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            text: z.string().min(1).max(10000).describe('Free-form text to extract lessons from.'),
-        },
-    }, safeTracked('extract_lessons_from_text', (args) => Promise.resolve(handleExtractLessonsFromText(args))));
-    s.registerTool('knowledge_gap_detector', {
-        description: 'Detect knowledge gaps in a project: specs missing decisions documentation and lesson categories with no entries.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-        },
-    }, safeTracked('knowledge_gap_detector', async (args) => handleKnowledgeGapDetector(args)));
-    s.registerTool('knowledge_summary', {
-        description: 'Get a snapshot of institutional knowledge: total decisions, lessons, spec coverage, top categories, and detected gaps.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-        },
-    }, safeTracked('knowledge_summary', async (args) => handleKnowledgeSummary(args)));
-    // ── Backlog tools ──────────────────────────────────────────────────────────
-    s.registerTool('capture_idea', {
-        description: 'Capture a lightweight idea or future possibility without creating a full spec. ' +
-            'Use when the user expresses non-urgent ideas (e.g. "sería bueno", "a futuro", "what if"). ' +
-            'Ideas expire after 90 days and can later be promoted to a spec with promote_idea.',
-        inputSchema: {
-            ...projectIdSchema,
-            title: z.string().min(3).max(200).describe('Short title for the idea.'),
-            description: z
-                .string()
-                .min(5)
-                .max(2000)
-                .describe('Detailed description of the idea or future possibility.'),
-            tags: z
-                .array(z.string().max(50))
-                .max(10)
-                .optional()
-                .describe('Optional tags to group related ideas (e.g. ["ux", "performance"]).'),
-        },
-        annotations: { readOnlyHint: false },
-    }, safeLicensed('capture_idea', withProject((args) => handleCaptureIdea(args))));
-    s.registerTool('list_backlog', {
-        description: 'List all captured ideas in the project backlog. ' +
-            'Optionally filter by status or tag. Groups results by tag. ' +
-            'Expired ideas are shown with a ⚠️ indicator.',
-        inputSchema: {
-            ...projectIdSchema,
-            status: z
-                .enum(['new', 'in-review', 'converted', 'discarded'])
-                .optional()
-                .describe('Filter by idea status. Valid values: new | in-review | converted | discarded'),
-            tag: z.string().max(50).optional().describe('Filter by a specific tag (exact match).'),
-        },
-        annotations: { readOnlyHint: true },
-    }, safeLicensed('list_backlog', withProject((args) => handleListBacklog(args))));
-    s.registerTool('promote_idea', {
-        description: 'Promote a backlog idea to a full spec by calling create_spec internally. ' +
-            'Only ideas with status "new" or "in-review" can be promoted. ' +
-            'After promotion the idea is marked as "converted" with the resulting specId.',
-        inputSchema: {
-            ...projectIdSchema,
-            ideaId: z.string().min(1).describe('ID of the idea to promote (e.g. "idea-20260321-001").'),
-        },
-        annotations: { readOnlyHint: false },
-    }, safeLicensed('promote_idea', withProject((args) => handlePromoteIdea(args))));
-    s.registerTool('discard_idea', {
-        description: 'Mark a backlog idea as discarded with a reason. ' +
-            'Idempotent — calling this on an already-discarded idea is safe and returns a confirmation.',
-        inputSchema: {
-            ...projectIdSchema,
-            ideaId: z.string().min(1).describe('ID of the idea to discard (e.g. "idea-20260321-001").'),
-            reason: z
-                .string()
-                .min(3)
-                .max(500)
-                .describe('Reason for discarding the idea (shown in backlog history).'),
-        },
-        annotations: { readOnlyHint: false, destructiveHint: true },
-    }, safeLicensed('discard_idea', withProject((args) => handleDiscardIdea(args))));
-    // ── Agent tools ────────────────────────────────────────────────────────────
-    s.registerTool('orchestrate_agents', {
-        description: 'Declare agent capabilities, route tasks to the best agent, generate structured handoff contexts, and detect file-ownership conflicts before parallel execution. Supports register-agent | list-agents | route-task | decompose-spec | handoff | conflict-check.',
-        inputSchema: {
-            action: z
-                .enum([
-                'register-agent',
-                'list-agents',
-                'route-task',
-                'decompose-spec',
-                'handoff',
-                'conflict-check',
-            ])
-                .describe('Action: register-agent (declare capability) | list-agents (list registered) | route-task (assign best agent) | decompose-spec (triad distribution) | handoff (structured context) | conflict-check (file overlap detection)'),
-            projectId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Project ID for persistence — defaults to "global"'),
-            agentId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('register-agent: unique identifier for the agent'),
-            role: z
-                .enum(['planner', 'implementer', 'reviewer', 'tester', 'researcher'])
-                .optional()
-                .describe('register-agent: primary role the agent fulfils'),
-            ecosystems: z
-                .array(z.string().max(500))
-                .max(100)
-                .optional()
-                .describe('register-agent: ecosystems the agent handles (e.g. ["typescript","python"])'),
-            filePatterns: z
-                .array(z.string().max(4096))
-                .max(1000)
-                .optional()
-                .describe('register-agent: glob patterns for files the agent owns'),
-            maxConcurrency: z
-                .number()
-                .int()
-                .positive()
-                .optional()
-                .describe('register-agent: max concurrent tasks (default: 1)'),
-            preferredModel: z
-                .enum(['haiku', 'sonnet', 'opus'])
-                .optional()
-                .describe('register-agent: preferred model tier (default: sonnet)'),
-            taskDescription: z
-                .string()
-                .max(10_000)
-                .optional()
-                .describe('route-task | decompose-spec: natural-language description of the task'),
-            specCriteria: z
-                .array(z.string().max(10_000))
-                .max(1000)
-                .optional()
-                .describe('decompose-spec: acceptance criteria to distribute across agents'),
-            availableAgents: z
-                .array(z.string().max(500))
-                .max(100)
-                .optional()
-                .describe('decompose-spec: agent IDs available for assignment'),
-            sessionContext: z
-                .object({
-                fromAgent: z.string().max(500).describe('Agent ID handing off work'),
-                toAgent: z.string().max(500).describe('Agent ID receiving work'),
-                completedWork: z
-                    .array(z.string().max(10_000))
-                    .max(1000)
-                    .describe('Short descriptions of completed work'),
-                decisions: z
-                    .array(z.object({ decision: z.string().max(10_000), rationale: z.string().max(10_000) }))
-                    .max(1000)
-                    .describe('Architectural decisions made during the session'),
-                fileOwnershipMap: z
-                    .record(z.string().max(4096), z.string().max(500))
-                    .describe('Map of file path → agentId that last modified it'),
-                pendingWork: z
-                    .array(z.object({ task: z.string().max(10_000), context: z.string().max(10_000) }))
-                    .max(1000)
-                    .describe('Unfinished tasks with context for the receiving agent'),
-            })
-                .optional()
-                .describe('handoff: session context object'),
-            agentPlans: z
-                .array(z.object({
-                agentId: z.string().max(500).describe('Agent ID submitting this plan'),
-                ownedFiles: z
-                    .array(z.string().max(4096))
-                    .max(1000)
-                    .describe('Files the agent intends to modify'),
-            }))
-                .optional()
-                .describe('conflict-check: array of per-agent plans'),
-        },
-        annotations: { readOnlyHint: false },
-    }, safeLicensed('orchestrate_agents', async (args) => handleOrchestrateAgents(args)));
-    // ── Agent squad tools ──────────────────────────────────────────────────────
-    // NOTE: registerAgentSquadHandlers() (event bus) stays in index.ts — NOT inlined here.
-    s.registerTool('configure_squad', {
-        description: 'Enable or disable a specific specialist agent for a project. ' +
-            'Overrides the default enabled state in agent-registry.json without modifying it. ' +
-            'Valid agentIds: figma-agent, developer-agent, code-reviewer-agent, ' +
-            'security-reviewer-agent, qa-agent, arbiter-agent, docs-agent.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            agentId: z
-                .string()
-                .min(1)
-                .max(100)
-                .describe('ID of the specialist agent to configure. Valid values: figma-agent, developer-agent, code-reviewer-agent, security-reviewer-agent, qa-agent, arbiter-agent, docs-agent.'),
-            enabled: z
-                .boolean()
-                .describe('Set to true to enable the agent, false to disable it for this project.'),
-        },
-    }, safeLicensed('configure_squad', async (args) => {
-        const { projectPath, agentId, enabled } = args;
-        const projectId = hashProjectPath(projectPath);
-        await setAgentEnabled(projectId, agentId, enabled);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Agent ${agentId} ${enabled ? 'enabled' : 'disabled'} for this project.`,
-                },
-            ],
-        };
-    }));
-    s.registerTool('squad_status', {
-        description: 'Show all registered specialist agents for a project, ' +
-            'whether they are enabled, and their last run result per spec. ' +
-            'Reflects any per-project overrides set via configure_squad.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-        },
-    }, safeTracked('squad_status', async (args) => {
-        const { projectPath } = args;
-        const projectId = hashProjectPath(projectPath);
-        const [config, runs] = await Promise.all([
-            getSquadConfig(projectId),
-            getSquadRuns(projectId),
-        ]);
-        const overrideMap = new Map(config.overrides.map((o) => [o.agentId, o.enabled]));
-        const recentByAgent = new Map();
-        for (const history of runs) {
-            const last = history.runs.at(-1);
-            if (last) {
-                const existing = recentByAgent.get(last.agentId);
-                if (!existing || last.triggeredAt > existing) {
-                    recentByAgent.set(last.agentId, `${last.verdict} (${history.specId})`);
-                }
-            }
-        }
-        const agents = [
-            'figma-agent',
-            'developer-agent',
-            'code-reviewer-agent',
-            'security-reviewer-agent',
-            'qa-agent',
-            'arbiter-agent',
-            'docs-agent',
-        ];
-        const lines = agents.map((id) => {
-            const enabled = overrideMap.get(id) ?? true;
-            const last = recentByAgent.get(id) ?? 'no runs yet';
-            return `${enabled ? '✅' : '❌'} ${id} — last: ${last}`;
-        });
-        return { content: [{ type: 'text', text: lines.join('\n') }] };
-    }));
-    s.registerTool('agent_run_history', {
-        description: 'Show the history of specialist agent runs for a specific spec: ' +
-            'which agents ran, their verdict, and when.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root.'),
-            specId: z.string().min(1).max(100).describe('Spec ID to query (e.g. SPEC-550).'),
-        },
-    }, safeTracked('agent_run_history', async (args) => {
-        const { projectPath, specId } = args;
-        const projectId = hashProjectPath(projectPath);
-        const history = await getSpecRunHistory(projectId, specId);
-        if (!history || history.runs.length === 0) {
-            return {
-                content: [{ type: 'text', text: `No agent runs recorded for ${specId}.` }],
-            };
-        }
-        const lines = history.runs.map((r) => `[${r.triggeredAt}] ${r.agentId} (${r.phase}) — ${r.verdict}: ${r.summary}`);
-        return { content: [{ type: 'text', text: lines.join('\n') }] };
-    }));
-    // ── Orchestrator tools ─────────────────────────────────────────────────────
-    s.registerTool('orchestrate_runtime', {
-        description: 'Launch and coordinate parallel agents with configurable topologies (mesh, hierarchical, pipeline, star). Distributes tasks, manages file ownership, collects results, and resolves conflicts. Supports dryRun mode for planning without execution.',
-        inputSchema: {
-            topology: z
-                .enum(['mesh', 'hierarchical', 'pipeline', 'star'])
-                .describe('Topology: mesh (parallel) | hierarchical (coordinator+workers) | pipeline (sequential) | star (hub-spoke)'),
-            tasks: z.array(taskDescriptionSchema).max(1000).describe('Tasks to distribute'),
-            agents: z
-                .array(agentConfigSchema)
-                .max(100)
-                .optional()
-                .describe('Agent configs (auto-generated if omitted)'),
-            maxRetries: z.number().min(0).optional().describe('Max retries per agent (default: 2)'),
-            timeoutMs: z.number().optional().describe('Timeout per agent in ms (default: 600000)'),
-            failFast: z.boolean().optional().describe('Stop on first failure (default: false)'),
-            spawnMethod: z
-                .enum(['cli-subprocess', 'mcp-client', 'http-endpoint'])
-                .optional()
-                .describe('Spawn method: cli-subprocess | mcp-client | http-endpoint'),
-            conflictStrategy: z
-                .enum(['last-wins', 'first-wins', 'merge-auto', 'flag-for-review'])
-                .optional()
-                .describe('Conflict strategy: last-wins | first-wins | merge-auto | flag-for-review'),
-            dryRun: z.boolean().optional().describe('Plan without executing (default: false)'),
-            templateId: z.string().max(500).optional().describe('Use a pre-defined template'),
-        },
-        annotations: { readOnlyHint: false },
-    }, safeLicensed('orchestrate_runtime', async (args) => handleOrchestrateRuntime(args)));
-    s.registerTool('agent_swarm_status', {
-        description: 'Get status of orchestration sessions. Returns agent progress, task status, metrics, and cost. Without sessionId, lists all sessions.',
-        inputSchema: {
-            sessionId: z.string().max(500).optional().describe('Specific session ID to query'),
-            status: z
-                .enum(['running', 'completed', 'failed'])
-                .optional()
-                .describe('Filter by status: running | completed | failed'),
-            agentId: z.string().max(500).optional().describe('Filter by specific agent ID'),
-        },
-        annotations: { readOnlyHint: true },
-    }, safeLicensed('agent_swarm_status', (args) => Promise.resolve(handleAgentSwarmStatus(args))));
-    // ── Delete tools ───────────────────────────────────────────────────────────
-    s.registerTool('delete_spec', {
-        description: 'Delete one or more specs from a project. Shows a preview by default — set confirm=true to execute. Soft delete (moves to trash) by default — set force=true for permanent deletion. ' +
-            'If the response contains interactiveQuestions[], present them to the user using AskUserQuestion (Claude Code) or equivalent interactive UI. DO NOT display the JSON as text.',
-        inputSchema: {
-            projectRoot: z.string().max(4096).describe('Absolute path to the project root'),
-            specId: z
-                .union([z.string().max(500), z.array(z.string().max(500)).max(100)])
-                .describe('Spec ID or array of spec IDs to delete'),
-            confirm: z
-                .boolean()
-                .optional()
-                .describe('Set to true to execute deletion. Without it, only a preview is shown.'),
-            force: z
-                .boolean()
-                .optional()
-                .describe('Set to true for permanent (hard) deletion. Default is soft delete (trash).'),
-        },
-        annotations: { title: 'Delete Spec', destructiveHint: true },
-    }, safeTracked('delete_spec', async (args) => handleDeleteSpec(args)));
-    s.registerTool('delete_project', {
-        description: 'Delete all data for a project. Shows a preview by default — requires confirm=true to execute. Soft delete (moves to trash) by default — set force=true for permanent deletion.',
-        inputSchema: {
-            projectRoot: z.string().max(4096).describe('Absolute path to the project root'),
-            confirm: z
-                .boolean()
-                .optional()
-                .describe('Set to true to execute deletion. Without it, only a preview is shown.'),
-            force: z
-                .boolean()
-                .optional()
-                .describe('Set to true for permanent (hard) deletion. Default is soft delete (trash).'),
-        },
-        annotations: { title: 'Delete Project', destructiveHint: true },
-    }, safeTracked('delete_project', async (args) => handleDeleteProject(args)));
-    s.registerTool('delete_pattern', {
-        description: 'Delete one or more learned patterns from a project. Shows a preview by default — set confirm=true to execute.',
-        inputSchema: {
-            projectRoot: z.string().max(4096).describe('Absolute path to the project root'),
-            patternId: z
-                .union([z.string().max(500), z.array(z.string().max(500)).max(100)])
-                .describe('Pattern ID or array of pattern IDs to delete'),
-            confirm: z
-                .boolean()
-                .optional()
-                .describe('Set to true to execute deletion. Without it, only a preview is shown.'),
-            force: z
-                .boolean()
-                .optional()
-                .describe('Set to true for permanent (hard) deletion. Default is soft delete (trash).'),
-        },
-        annotations: { title: 'Delete Pattern', destructiveHint: true },
-    }, safeTracked('delete_pattern', async (args) => handleDeletePattern(args)));
-    s.registerTool('delete_decision', {
-        description: 'Delete one or more decisions/ADRs from a project. Shows a preview by default — set confirm=true to execute.',
-        inputSchema: {
-            projectRoot: z.string().max(4096).describe('Absolute path to the project root'),
-            decisionId: z
-                .union([z.string().max(500), z.array(z.string().max(500)).max(100)])
-                .describe('Decision ID or array of decision IDs to delete'),
-            confirm: z
-                .boolean()
-                .optional()
-                .describe('Set to true to execute deletion. Without it, only a preview is shown.'),
-            force: z
-                .boolean()
-                .optional()
-                .describe('Set to true for permanent (hard) deletion. Default is soft delete (trash).'),
-        },
-        annotations: { title: 'Delete Decision', destructiveHint: true },
-    }, safeTracked('delete_decision', async (args) => handleDeleteDecision(args)));
-    s.registerTool('manage_trash', {
-        description: 'Manage the trash for a project. Actions: list (show trashed items), restore (restore an item from trash), purge (permanently delete trash items).',
-        inputSchema: {
-            projectRoot: z.string().max(4096).describe('Absolute path to the project root'),
-            action: TrashActionEnum.describe('Action to perform: list | restore | purge'),
-            itemId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Trash item ID — required for restore, optional for purge (omit to purge all)'),
-        },
-        annotations: { title: 'Manage Trash', destructiveHint: true },
-    }, safeTracked('manage_trash', async (args) => handleManageTrash(args)));
-    // ── Delete-first tools ─────────────────────────────────────────────────────
-    s.registerTool('suggest_deletions', {
-        description: 'Scan a project for code that should be deleted: dead exports, duplicated blocks, ' +
-            'single-impl interfaces, permanent feature flags, and wrapper functions. ' +
-            'Returns a ranked markdown table of candidates with severity and suggested action.',
-        inputSchema: SuggestDeletionsInputSchema,
-        annotations: {
-            title: 'Suggest Deletions',
-            readOnlyHint: true,
-            destructiveHint: false,
-            openWorldHint: false,
-        },
-    }, safeTracked('suggest_deletions', async (args) => handleSuggestDeletions(args)));
-    s.registerTool('sustainability_score', {
-        description: 'Compute a sustainability score (0-100, grade A-F) per module and for the whole project. ' +
-            'Score = simplicity × cohesion / (1 + coupling/10) × 100. ' +
-            'Returns a ranked table of worst modules with per-dimension breakdown.',
-        inputSchema: SustainabilityScoreInputSchema,
-        annotations: {
-            title: 'Sustainability Score',
-            readOnlyHint: true,
-            destructiveHint: false,
-            openWorldHint: false,
-        },
-    }, safeTracked('sustainability_score', async (args) => handleSustainabilityScore(args)));
-    s.registerTool('simplicity_metric', {
-        description: 'Measure code simplicity per file: avg function length, max nesting depth, ' +
-            'ternary chains, regex patterns, and avg parameter count. ' +
-            'Returns a grade A-F and ranked table of most complex files.',
-        inputSchema: SimplicityMetricInputSchema,
-        annotations: {
-            title: 'Simplicity Metric',
-            readOnlyHint: true,
-            destructiveHint: false,
-            openWorldHint: false,
-        },
-    }, safeTracked('simplicity_metric', async (args) => handleSimplicityMetric(args)));
-    // ── Legacy tools ───────────────────────────────────────────────────────────
-    s.registerTool('characterize_legacy_code', {
-        description: 'Generate characterization test stubs for existing functions in legacy code. ' +
-            'Stubs call each function with inferred sample inputs and leave TODO placeholders ' +
-            'for the developer to fill in the observed expected values. ' +
-            'Use before any refactoring to lock in current behavior.',
-        inputSchema: CharacterizeLegacyCodeInputSchema,
-        annotations: {
-            title: 'Characterize Legacy Code',
-            readOnlyHint: false,
-            destructiveHint: false,
-            openWorldHint: false,
-        },
-    }, safeTracked('characterize_legacy_code', async (args) => handleCharacterizeLegacyCode(args)));
-    s.registerTool('detect_hyrum_risks', {
-        description: "Scan a project's public API surface for Hyrum's Law risks: observable behaviors " +
-            'that callers may depend on even though they are undocumented. ' +
-            'Detects: exception types thrown, return object shapes, null vs undefined returns, ' +
-            'sort ordering guarantees, and error message text.',
-        inputSchema: DetectHyrumRisksInputSchema,
-        annotations: {
-            title: "Detect Hyrum's Law Risks",
-            readOnlyHint: true,
-            destructiveHint: false,
-            openWorldHint: false,
-        },
-    }, safeTracked('detect_hyrum_risks', async (args) => handleDetectHyrumRisks(args)));
-    s.registerTool('seams_detector', {
-        description: 'Scan TypeScript/JavaScript files for dependency break points (seams) that make ' +
-            'code difficult to test and refactor. ' +
-            'Detects: static method calls (ClassName.method), process.env globals, ' +
-            'inline new ExpensiveDep() inside functions, hardcoded file paths, and hardcoded URLs.',
-        inputSchema: SeamsDetectorInputSchema,
-        annotations: {
-            title: 'Detect Seams',
-            readOnlyHint: true,
-            destructiveHint: false,
-            openWorldHint: false,
-        },
-    }, safeTracked('seams_detector', async (args) => handleSeamsDetector(args)));
-    s.registerTool('refactor_with_safety_net', {
-        description: 'Orchestrator tool: detects coverage baseline, adds characterization tests, plans ' +
-            'incremental refactoring steps, and validates behavior at each step. ' +
-            'Returns a sequenced safety-net plan — no production code is changed automatically. ' +
-            'Use after characterize_legacy_code and seams_detector to get a full action plan.',
-        inputSchema: RefactorWithSafetyNetInputSchema,
-        annotations: {
-            title: 'Refactor with Safety Net',
-            readOnlyHint: false,
-            destructiveHint: false,
-            openWorldHint: false,
-        },
-    }, safeTracked('refactor_with_safety_net', async (args) => handleRefactorWithSafetyNet(args)));
-    // ── Elicitation tools ──────────────────────────────────────────────────────
-    s.registerTool('elicit_requirements', {
-        description: 'Interactively clarify requirements before creating a spec. ' +
-            'First call returns structured questions for the user to answer. ' +
-            'Second call (with answers + sessionId) returns a structured summary ready to pass to create_spec.',
-        inputSchema: {
-            ...projectIdSchema,
-            title: z.string().min(3).max(200).describe('Feature title to clarify requirements for.'),
-            description: z
-                .string()
-                .min(10)
-                .max(2000)
-                .describe('Initial description of the feature or change.'),
-            answers: z
-                .string()
-                .max(3000)
-                .optional()
-                .describe('User answers to the clarification questions (numbered list). Provide this on the follow-up call to get a spec-ready summary.'),
-            sessionId: z
-                .string()
-                .max(100)
-                .optional()
-                .describe('Session ID returned from the previous call. Pass this on the follow-up call to continue the same elicitation session.'),
-        },
-        annotations: { title: 'Elicit Requirements', readOnlyHint: false },
-    }, safeLicensed('elicit_requirements', withProject((args) => handleElicitRequirements(args))));
-    // ── Context tools ──────────────────────────────────────────────────────────
-    s.registerTool('request_context', {
-        description: 'Generate a prompt that asks the user for reference documentation (README, PRD, ' +
-            'architecture diagrams, wireframes, ADRs, etc.) so the agent can learn the project. ' +
-            'Sets a flag to avoid re-asking on subsequent calls. Use force=true to re-generate.',
-        annotations: { readOnlyHint: true },
-        inputSchema: {
-            projectId: z
-                .string()
-                .max(500)
-                .describe('Project ID (hash of project path from init_project)'),
-            force: z
-                .boolean()
-                .optional()
-                .describe('Force re-generation even if already requested (default: false)'),
-        },
-    }, safeLicensed('request_context', async (args) => handleRequestContext(args)));
-    s.registerTool('contribute_context', {
-        description: 'Persist structured knowledge that the agent extracted from user-provided documents. ' +
-            'Merges intelligently with auto-detected knowledge; reports conflicts for agent resolution. ' +
-            'Multiple calls accumulate — they do not overwrite each other.',
-        annotations: { readOnlyHint: false },
-        inputSchema: {
-            projectId: z
-                .string()
-                .max(500)
-                .describe('Project ID (hash of project path from init_project)'),
-            context: z
-                .object({
-                entities: z
-                    .array(z.object({
-                    name: z.string().max(500).describe('Entity / model name'),
-                    fields: z.array(z.string().max(500)).max(1000).describe('Field names'),
-                    relations: z
-                        .array(z.string().max(500))
-                        .max(100)
-                        .optional()
-                        .describe('Related entity names'),
-                }))
-                    .max(1000)
-                    .optional()
-                    .describe('Data entities / models extracted from the docs'),
-                apiContracts: z
-                    .array(z.object({
-                    type: z
-                        .enum(['rest', 'graphql', 'trpc', 'grpc', 'websocket'])
-                        .describe('Contract type'),
-                    endpoint: z.string().max(4096).optional().describe('Base endpoint or path'),
-                    description: z.string().max(10_000).describe('What this API does'),
-                }))
-                    .max(1000)
-                    .optional()
-                    .describe('API contract descriptions'),
-                architectureNotes: z
-                    .string()
-                    .max(10_000)
-                    .optional()
-                    .describe('Architecture decisions and patterns from the docs'),
-                techDecisions: z
-                    .array(z.string().max(10_000))
-                    .max(1000)
-                    .optional()
-                    .describe('Key technical decisions recorded in ADRs or equivalent'),
-                userFlows: z
-                    .array(z.string().max(10_000))
-                    .max(1000)
-                    .optional()
-                    .describe('User journey descriptions from wireframes or PRD'),
-                nonFunctionalRequirements: z
-                    .array(z.string().max(10_000))
-                    .max(1000)
-                    .optional()
-                    .describe('Performance, security, and scalability requirements'),
-                additionalContext: z
-                    .string()
-                    .max(10_000)
-                    .optional()
-                    .describe('Free-text additional context (max 10 000 chars)'),
-            })
-                .describe('Structured knowledge extracted from the user documents'),
-            source: z
-                .object({
-                documentName: z
-                    .string()
-                    .max(500)
-                    .describe('Name or description of the source document (e.g. "README.md", "PRD v2")'),
-                contributedAt: z
-                    .string()
-                    .max(500)
-                    .describe('ISO 8601 timestamp of when this contribution was made'),
-                contributedBy: z
-                    .string()
-                    .max(500)
-                    .describe('Agent identifier (e.g. "claude-code", "cursor")'),
-            })
-                .describe('Trace metadata for this contribution'),
-        },
-    }, safeLicensed('contribute_context', async (args) => handleContributeContext(args)));
-    // ── Context manager tools ──────────────────────────────────────────────────
-    s.registerTool('context_window_status', {
-        description: 'Estimate the number of tokens consumed by the project context. ' +
-            'Uses heuristics: ~1,500 tokens per spec, ~200 per decision, ~150 per lesson. ' +
-            'Shows breakdown by category and compares to configured budget.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root directory'),
-        },
-        annotations: { title: 'Context Window Status', readOnlyHint: true },
-    }, safeLicensed('context_window_status', async (args) => handleContextWindowStatus(args)));
-    s.registerTool('optimize_context', {
-        description: 'Identify specs that are candidates for archiving to reduce context token usage. ' +
-            'Candidates are done specs older than the configured archiveAfterDays threshold. ' +
-            'Use action="apply" to actually archive them.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root directory'),
-            action: z
-                .enum(['suggest', 'apply'])
-                .optional()
-                .describe('Action to take. Valid values: suggest (default, lists candidates) | apply (archives candidates)'),
-        },
-        annotations: { title: 'Optimize Context', readOnlyHint: false },
-    }, safeLicensed('optimize_context', async (args) => handleOptimizeContext(args)));
-    s.registerTool('context_budget_config', {
-        description: 'Configure the context window budget: maximum tokens, warning threshold, archiving strategy, ' +
-            'and number of days after which done specs are eligible for archiving.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .min(1)
-                .max(4096)
-                .describe('Absolute path to the project root directory'),
-            maxTokens: z
-                .number()
-                .int()
-                .min(10_000)
-                .max(2_000_000)
-                .optional()
-                .describe('Maximum token budget (default: 200,000)'),
-            strategy: z
-                .enum(['archive-oldest', 'archive-done', 'compress-history', 'manual'])
-                .optional()
-                .describe(STRATEGY_DESCRIBE),
-            warnAt: z
-                .number()
-                .int()
-                .min(1_000)
-                .optional()
-                .describe('Token count at which to warn (default: 150,000)'),
-            archiveAfterDays: z
-                .number()
-                .int()
-                .min(1)
-                .optional()
-                .describe('Days after done before a spec is eligible for archiving (default: 30)'),
-        },
-        annotations: { title: 'Configure Context Budget', readOnlyHint: false },
-    }, safeLicensed('context_budget_config', async (args) => handleContextBudgetConfig(args)));
-    s.registerTool('archive_spec_context', {
-        description: 'Archive a specific spec to the archived-context/ directory to free up context tokens. ' +
-            'The spec data is preserved and can be restored with restore_archived_context.',
-        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 to archive (e.g. SPEC-001)'),
-        },
-        annotations: { title: 'Archive Spec Context', readOnlyHint: false, destructiveHint: false },
-    }, safeLicensed('archive_spec_context', async (args) => handleArchiveSpecContext(args)));
-    s.registerTool('compress_spec_history', {
-        description: 'Describe what would happen when compressing spec version history, keeping only the most recent N versions. ' +
-            'Reduces token usage from version diffs stored in spec-version-history.',
-        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 whose version history to compress'),
-            keepVersions: z
-                .number()
-                .int()
-                .min(1)
-                .max(50)
-                .optional()
-                .describe('Number of recent versions to keep (default: 3)'),
-        },
-        annotations: { title: 'Compress Spec History', readOnlyHint: false, destructiveHint: true },
-    }, safeLicensed('compress_spec_history', (args) => Promise.resolve(handleCompressSpecHistory(args))));
-    s.registerTool('restore_archived_context', {
-        description: 'Restore a previously archived spec from archived-context/ back to the active project context.',
-        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 to restore from archive'),
-        },
-        annotations: { title: 'Restore Archived Context', readOnlyHint: false },
-    }, safeLicensed('restore_archived_context', async (args) => handleRestoreArchivedContext(args)));
-    // ── Scope tools ────────────────────────────────────────────────────────────
-    s.registerTool('manage_scope', {
-        description: 'Manage the project scope definition and backlog. ' +
-            'View current scope, list backlog items, add deferred requirements to backlog, ' +
-            'or propose a formal scope change (requires explicit approval and reason).',
-        inputSchema: {
-            ...projectIdSchema,
-            operation: z
-                .enum(['view', 'add_to_backlog', 'propose_change', 'list_backlog'])
-                .describe('view: show current scope; list_backlog: list deferred items; add_to_backlog: defer a requirement; propose_change: formally change scope'),
-            itemDescription: z
-                .string()
-                .max(10_000)
-                .optional()
-                .describe('Description of the item to defer (required for add_to_backlog)'),
-            exclusionReason: z
-                .string()
-                .max(10_000)
-                .optional()
-                .describe('Why this item is not in the current scope (required for add_to_backlog)'),
-            specId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Associated spec ID (optional for add_to_backlog)'),
-            newScope: z
-                .object({
-                platforms: z
-                    .array(z.string().max(500))
-                    .max(100)
-                    .optional()
-                    .describe('Target platforms'),
-                targetUsers: z
-                    .array(z.string().max(500))
-                    .max(100)
-                    .optional()
-                    .describe('Target user types'),
-                primaryProblem: z
-                    .string()
-                    .max(10_000)
-                    .optional()
-                    .describe('The core problem being solved'),
-            })
-                .optional()
-                .describe('New scope definition (required for propose_change)'),
-            changeReason: z
-                .string()
-                .max(10_000)
-                .optional()
-                .describe('Business reason for scope change (required for propose_change)'),
-            approvedBy: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Name of the person approving the change (required for propose_change)'),
-        },
-        annotations: { readOnlyHint: false },
-    }, safeLicensed('manage_scope', withProject((args) => handleManageScope(args))));
-    s.registerTool('detect_contradictions', {
-        description: 'Analyze all specs in a project for semantic contradictions. ' +
-            'Detects patterns like offline vs real-time, sync vs async, simple vs complex, ' +
-            'performance vs security, local vs cloud. ' +
-            'Returns a report with severity (blocker/warning) and recommendations.',
-        inputSchema: {
-            ...projectIdSchema,
-        },
-        annotations: { readOnlyHint: true },
-    }, safeLicensed('detect_contradictions', withProject((args) => handleDetectContradictions(args))));
-}
-//# sourceMappingURL=group-session-knowledge.js.map