memory-journal-mcp 4.4.2 → 5.0.0

package/src/handlers/tools/index.ts

@@ -1,3377 +1,196 @@
 /**
- * Memory Journal MCP Server - Tool Handlers
+ * Tool Handler Barrel
  *
- * Exports all MCP tools with annotations following MCP 2025-11-25 spec.
+ * Composes all tool group modules and exposes the public API:
+ * - getTools(): returns filtered tool definitions for the MCP server
+ * - callTool(): dispatches a tool call by name
+ *
+ * Each group module owns its:
+ * - Input/output Zod schemas
+ * - Tool definitions (name, description, group, annotations)
+ * - Handler implementations (with try/catch + formatHandlerError)
  */
 
-import { z } from 'zod'
-import type { SqliteAdapter } from '../../database/SqliteAdapter.js'
-import type { ToolFilterConfig } from '../../filtering/ToolFilter.js'
 import type {
+    ToolFilterConfig,
     ToolDefinition,
-    EntryType,
-    SignificanceType,
-    RelationshipType,
+    ToolContext,
+    ToolHandlerConfig,
 } from '../../types/index.js'
+import type { SqliteAdapter } from '../../database/SqliteAdapter.js'
 import type { VectorSearchManager } from '../../vector/VectorSearchManager.js'
 import type { GitHubIntegration } from '../../github/GitHubIntegration.js'
-import { sendProgress, type ProgressContext } from '../../utils/progress-utils.js'
-import { getToolIcon } from '../../constants/icons.js'
-
-export interface ToolHandlerConfig {
-    defaultProjectNumber?: number
-}
-
-/**
- * Tool execution context
- */
-export interface ToolContext {
-    db: SqliteAdapter
-    vectorManager?: VectorSearchManager
-    github?: GitHubIntegration
-    config?: ToolHandlerConfig
-    progress?: ProgressContext
+import type { ProgressContext } from '../../utils/progress-utils.js'
+
+import { getCoreTools } from './core.js'
+import { getSearchTools } from './search.js'
+import { getAnalyticsTools } from './analytics.js'
+import { getRelationshipTools } from './relationships.js'
+import { getExportTools } from './export.js'
+import { getAdminTools } from './admin.js'
+import { getGitHubTools } from './github.js'
+import { getBackupTools } from './backup.js'
+import { getTeamTools } from './team.js'
+
+// Re-export for backward compatibility (McpServer imports these)
+export type { ToolHandlerConfig }
+
+// ============================================================================
+// Icon Mapping
+// ============================================================================
+
+function getToolIcon(
+    group: string
+): { iconUrl: string; title: string; description: string } | undefined {
+    const iconMap: Record<string, { iconUrl: string; title: string; description: string }> = {
+        core: {
+            iconUrl: 'https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/notebook.svg',
+            title: 'Journal Core',
+            description: 'Core journal operations',
+        },
+        search: {
+            iconUrl: 'https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/magnify.svg',
+            title: 'Search',
+            description: 'Entry search operations',
+        },
+        analytics: {
+            iconUrl: 'https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/chart-bar.svg',
+            title: 'Analytics',
+            description: 'Journal analytics',
+        },
+        relationships: {
+            iconUrl: 'https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/graph-outline.svg',
+            title: 'Relationships',
+            description: 'Entry relationship management',
+        },
+        export: {
+            iconUrl: 'https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/export.svg',
+            title: 'Export',
+            description: 'Data export operations',
+        },
+        admin: {
+            iconUrl: 'https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/cog.svg',
+            title: 'Admin',
+            description: 'Administrative operations',
+        },
+        github: {
+            iconUrl: 'https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/github.svg',
+            title: 'GitHub',
+            description: 'GitHub integration',
+        },
+        backup: {
+            iconUrl: 'https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/backup-restore.svg',
+            title: 'Backup',
+            description: 'Backup and restore',
+        },
+        team: {
+            iconUrl: 'https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/account-group.svg',
+            title: 'Team',
+            description: 'Team collaboration',
+        },
+    }
+    return iconMap[group]
 }
 
 // ============================================================================
-// Zod Schemas for Input Validation
-// ============================================================================
-
-const CreateEntrySchema = z.object({
-    content: z.string().min(1).max(50000),
-    entry_type: z.string().optional().default('personal_reflection'),
-    tags: z.array(z.string()).optional().default([]),
-    is_personal: z.boolean().optional().default(true),
-    significance_type: z.string().optional(),
-    auto_context: z.boolean().optional().default(true),
-    project_number: z.number().optional(),
-    project_owner: z.string().optional(),
-    issue_number: z.number().optional(),
-    issue_url: z.string().optional(),
-    pr_number: z.number().optional(),
-    pr_url: z.string().optional(),
-    pr_status: z.enum(['draft', 'open', 'merged', 'closed']).optional(),
-    workflow_run_id: z.number().optional(),
-    workflow_name: z.string().optional(),
-    workflow_status: z.enum(['queued', 'in_progress', 'completed']).optional(),
-    share_with_team: z.boolean().optional().default(false),
-})
-
-const GetEntryByIdSchema = z.object({
-    entry_id: z.number(),
-    include_relationships: z.boolean().optional().default(true),
-})
-
-const GetRecentEntriesSchema = z.object({
-    limit: z.number().optional().default(5),
-    is_personal: z.boolean().optional(),
-})
-
-const CreateEntryMinimalSchema = z.object({
-    content: z.string().min(1).max(50000),
-})
-
-const TestSimpleSchema = z.object({
-    message: z.string().optional().default('Hello'),
-})
-
-const SearchEntriesSchema = z.object({
-    query: z.string().optional(),
-    limit: z.number().optional().default(10),
-    is_personal: z.boolean().optional(),
-    project_number: z.number().optional(),
-    issue_number: z.number().optional(),
-    pr_number: z.number().optional(),
-    pr_status: z.enum(['draft', 'open', 'merged', 'closed']).optional(),
-    workflow_run_id: z.number().optional(),
-})
-
-const SearchByDateRangeSchema = z.object({
-    start_date: z.string(),
-    end_date: z.string(),
-    entry_type: z.string().optional(),
-    tags: z.array(z.string()).optional(),
-    is_personal: z.boolean().optional(),
-    project_number: z.number().optional(),
-    issue_number: z.number().optional(),
-    pr_number: z.number().optional(),
-    workflow_run_id: z.number().optional(),
-})
-
-const SemanticSearchSchema = z.object({
-    query: z.string(),
-    limit: z.number().optional().default(10),
-    similarity_threshold: z.number().optional().default(0.25),
-    is_personal: z.boolean().optional(),
-    hint_on_empty: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe('Include hint when no results found (default: true)'),
-})
-
-const GetStatisticsSchema = z.object({
-    group_by: z.enum(['day', 'week', 'month']).optional().default('week'),
-    start_date: z.string().optional(),
-    end_date: z.string().optional(),
-    project_breakdown: z.boolean().optional().default(false),
-})
-
-const LinkEntriesSchema = z.object({
-    from_entry_id: z.number(),
-    to_entry_id: z.number(),
-    relationship_type: z
-        .enum([
-            'evolves_from',
-            'references',
-            'implements',
-            'clarifies',
-            'response_to',
-            'blocked_by',
-            'resolved',
-            'caused',
-        ])
-        .optional()
-        .default('references'),
-    description: z.string().optional(),
-})
-
-const ExportEntriesSchema = z.object({
-    format: z.enum(['json', 'markdown']).optional().default('json'),
-    start_date: z.string().optional(),
-    end_date: z.string().optional(),
-    entry_types: z.array(z.string()).optional(),
-    tags: z.array(z.string()).optional(),
-    limit: z.number().optional().default(100).describe('Maximum entries to export (default: 100)'),
-})
-
-const UpdateEntrySchema = z.object({
-    entry_id: z.number(),
-    content: z.string().optional(),
-    entry_type: z.string().optional(),
-    is_personal: z.boolean().optional(),
-    tags: z.array(z.string()).optional(),
-})
-
-const DeleteEntrySchema = z.object({
-    entry_id: z.number(),
-    permanent: z.boolean().optional().default(false),
-})
-
-// ============================================================================
-// Zod Schemas for Output Validation (MCP 2025-11-25 outputSchema)
+// Public API
 // ============================================================================
 
 /**
- * Schema for a journal entry in output responses.
- * Uses camelCase to match actual database output format.
- */
-const EntryOutputSchema = z.object({
-    id: z.number(),
-    content: z.string(),
-    entryType: z.string(),
-    isPersonal: z.boolean(),
-    timestamp: z.string(),
-    tags: z.array(z.string()).optional(),
-    significanceType: z.string().nullable().optional(),
-    autoContext: z.string().nullable().optional(),
-    deletedAt: z.string().nullable().optional(),
-    projectNumber: z.number().nullable().optional(),
-    projectOwner: z.string().nullable().optional(),
-    issueNumber: z.number().nullable().optional(),
-    issueUrl: z.string().nullable().optional(),
-    prNumber: z.number().nullable().optional(),
-    prUrl: z.string().nullable().optional(),
-    prStatus: z.string().nullable().optional(),
-    workflowRunId: z.number().nullable().optional(),
-    workflowName: z.string().nullable().optional(),
-    workflowStatus: z.string().nullable().optional(),
-})
-
-/**
- * Schema for list of entries with count.
- * Used by get_recent_entries, search_entries, search_by_date_range.
- */
-const EntriesListOutputSchema = z.object({
-    entries: z.array(EntryOutputSchema),
-    count: z.number(),
-})
-
-/**
- * Schema for a relationship between entries.
- */
-const RelationshipOutputSchema = z.object({
-    id: z.number(),
-    fromEntryId: z.number(),
-    toEntryId: z.number(),
-    relationshipType: z.string(),
-    description: z.string().nullable().optional(),
-    createdAt: z.string(),
-})
-
-/**
- * Schema for get_entry_by_id output (entry with optional relationships).
- * Handles both success (entry found) and error (entry not found) cases.
- */
-const ImportanceBreakdownSchema = z.object({
-    significance: z.number(),
-    relationships: z.number(),
-    causal: z.number(),
-    recency: z.number(),
-})
-
-const EntryByIdOutputSchema = z.object({
-    entry: EntryOutputSchema.optional(),
-    relationships: z.array(RelationshipOutputSchema).optional(),
-    importance: z.number().nullable().optional(), // Computed importance score (0.0-1.0)
-    importanceBreakdown: ImportanceBreakdownSchema.optional(), // Weighted component contributions
-    error: z.string().optional(),
-})
-
-/**
- * Schema for get_statistics output.
- * Matches SqliteAdapter.getStatistics() return type.
- */
-const StatisticsOutputSchema = z.object({
-    groupBy: z.string(),
-    totalEntries: z.number(),
-    entriesByType: z.record(z.string(), z.number()),
-    entriesByPeriod: z.array(
-        z.object({
-            period: z.string(),
-            count: z.number(),
-        })
-    ),
-    // Enhanced analytics (v4.3.0)
-    decisionDensity: z.array(
-        z.object({
-            period: z.string(),
-            significantCount: z.number(),
-        })
-    ),
-    relationshipComplexity: z.object({
-        totalRelationships: z.number(),
-        avgPerEntry: z.number(),
-    }),
-    activityTrend: z.object({
-        currentPeriod: z.string(),
-        previousPeriod: z.string(),
-        growthPercent: z.number().nullable(),
-    }),
-    causalMetrics: z.object({
-        blocked_by: z.number(),
-        resolved: z.number(),
-        caused: z.number(),
-    }),
-})
-
-// ============================================================================
-// Phase 1: Core Read Tool Output Schemas
-// ============================================================================
-
-/**
- * Entry with similarity score for semantic search results.
- */
-const SemanticEntryOutputSchema = EntryOutputSchema.extend({
-    similarity: z.number(),
-})
-
-/**
- * Schema for semantic_search output.
- */
-const SemanticSearchOutputSchema = z.object({
-    query: z.string(),
-    entries: z.array(SemanticEntryOutputSchema),
-    count: z.number(),
-    hint: z.string().optional(),
-    error: z.string().optional(),
-})
-
-/**
- * Tag with usage count.
- */
-const TagOutputSchema = z.object({
-    name: z.string(),
-    count: z.number(),
-})
-
-/**
- * Schema for list_tags output.
- */
-const TagsListOutputSchema = z.object({
-    tags: z.array(TagOutputSchema),
-    count: z.number(),
-})
-
-/**
- * Schema for merge_tags output.
- */
-const MergeTagsOutputSchema = z.object({
-    success: z.boolean(),
-    sourceTag: z.string(),
-    targetTag: z.string(),
-    entriesUpdated: z.number(),
-    sourceDeleted: z.boolean(),
-    message: z.string(),
-    error: z.string().optional(),
-})
-
-/**
- * Schema for get_vector_index_stats output.
- */
-const VectorStatsOutputSchema = z.object({
-    available: z.boolean(),
-    error: z.string().optional(),
-    entryCount: z.number().optional(),
-    indexSize: z.number().optional(),
-})
-
-/**
- * Schema for visualize_relationships output.
- */
-const VisualizationOutputSchema = z.object({
-    entry_count: z.number(),
-    relationship_count: z.number(),
-    root_entry: z.number().nullable(),
-    depth: z.number(),
-    mermaid: z.string().nullable(),
-    message: z.string().optional(),
-    legend: z
-        .object({
-            blue: z.string(),
-            orange: z.string(),
-            arrows: z.record(z.string(), z.string()),
-        })
-        .optional(),
-})
-
-/**
- * Project summary for cross-project insights.
- */
-const ProjectSummaryOutputSchema = z.object({
-    project_number: z.number(),
-    entry_count: z.number(),
-    first_entry: z.string(),
-    last_entry: z.string(),
-    active_days: z.number(),
-    top_tags: z.array(TagOutputSchema),
-})
-
-/**
- * Schema for get_cross_project_insights output.
- */
-const CrossProjectInsightsOutputSchema = z.object({
-    project_count: z.number(),
-    total_entries: z.number(),
-    projects: z.array(ProjectSummaryOutputSchema),
-    inactive_projects: z.array(
-        z.object({
-            project_number: z.number(),
-            last_entry_date: z.string(),
-        })
-    ),
-    inactiveThresholdDays: z.number(), // Cutoff for inactive classification
-    time_distribution: z.array(
-        z.object({
-            project_number: z.number(),
-            percentage: z.string(),
-        })
-    ),
-    message: z.string().optional(),
-})
-
-// ============================================================================
-// Phase 2: Mutation Tool Output Schemas
-// ============================================================================
-
-/**
- * Schema for create_entry and create_entry_minimal output.
- */
-const CreateEntryOutputSchema = z.object({
-    success: z.boolean(),
-    entry: EntryOutputSchema,
-})
-
-/**
- * Schema for update_entry output (success or error).
- */
-const UpdateEntryOutputSchema = z.object({
-    success: z.boolean().optional(),
-    entry: EntryOutputSchema.optional(),
-    error: z.string().optional(),
-})
-
-/**
- * Schema for delete_entry output.
- */
-const DeleteEntryOutputSchema = z.object({
-    success: z.boolean(),
-    entryId: z.number(),
-    permanent: z.boolean(),
-    error: z.string().optional(),
-})
-
-/**
- * Schema for link_entries output.
- */
-const LinkEntriesOutputSchema = z.object({
-    success: z.boolean(),
-    relationship: RelationshipOutputSchema,
-    duplicate: z.boolean().optional().describe('True if relationship already existed'),
-    message: z.string().optional().describe('Additional context about the operation'),
-})
-
-// ============================================================================
-// Phase 3: GitHub Tool Output Schemas
-// ============================================================================
-
-/**
- * GitHub issue schema (mirrors GitHub API shape).
- */
-const GitHubIssueOutputSchema = z.object({
-    number: z.number(),
-    title: z.string(),
-    url: z.string(),
-    state: z.enum(['OPEN', 'CLOSED']),
-    milestone: z
-        .object({
-            number: z.number(),
-            title: z.string(),
-        })
-        .nullable()
-        .optional(),
-})
-
-/**
- * GitHub issue details schema (extended).
- */
-const GitHubIssueDetailsOutputSchema = GitHubIssueOutputSchema.extend({
-    body: z.string().nullable(),
-    labels: z.array(z.string()),
-    assignees: z.array(z.string()),
-    createdAt: z.string(),
-    updatedAt: z.string(),
-    closedAt: z.string().nullable(),
-    commentsCount: z.number(),
-})
-
-/**
- * Schema for get_github_issues output.
- */
-const GitHubIssuesListOutputSchema = z.object({
-    owner: z.string(),
-    repo: z.string(),
-    detectedOwner: z.string().nullable().optional(),
-    detectedRepo: z.string().nullable().optional(),
-    issues: z.array(GitHubIssueOutputSchema),
-    count: z.number(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-/**
- * Schema for get_github_issue output.
- */
-const GitHubIssueResultOutputSchema = z.object({
-    issue: GitHubIssueDetailsOutputSchema.optional(),
-    owner: z.string().optional(),
-    repo: z.string().optional(),
-    detectedOwner: z.string().nullable().optional(),
-    detectedRepo: z.string().nullable().optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-/**
- * GitHub pull request schema (mirrors GitHub API shape).
- */
-const GitHubPullRequestOutputSchema = z.object({
-    number: z.number(),
-    title: z.string(),
-    url: z.string(),
-    state: z.enum(['OPEN', 'CLOSED', 'MERGED']),
-})
-
-/**
- * GitHub PR details schema (extended).
- */
-const GitHubPRDetailsOutputSchema = GitHubPullRequestOutputSchema.extend({
-    body: z.string().nullable(),
-    draft: z.boolean(),
-    headBranch: z.string(),
-    baseBranch: z.string(),
-    author: z.string(),
-    createdAt: z.string(),
-    updatedAt: z.string(),
-    mergedAt: z.string().nullable(),
-    closedAt: z.string().nullable(),
-    additions: z.number(),
-    deletions: z.number(),
-    changedFiles: z.number(),
-})
-
-/**
- * Schema for get_github_prs output.
- */
-const GitHubPRsListOutputSchema = z.object({
-    owner: z.string(),
-    repo: z.string(),
-    detectedOwner: z.string().nullable().optional(),
-    detectedRepo: z.string().nullable().optional(),
-    pullRequests: z.array(GitHubPullRequestOutputSchema),
-    count: z.number(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-/**
- * Schema for get_github_pr output.
- */
-const GitHubPRResultOutputSchema = z.object({
-    pullRequest: GitHubPRDetailsOutputSchema.optional(),
-    owner: z.string().optional(),
-    repo: z.string().optional(),
-    detectedOwner: z.string().nullable().optional(),
-    detectedRepo: z.string().nullable().optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-/**
- * Schema for get_github_context output.
- */
-const GitHubContextOutputSchema = z.object({
-    repoName: z.string().nullable(),
-    branch: z.string().nullable(),
-    commit: z.string().nullable(),
-    remoteUrl: z.string().nullable(),
-    issues: z.array(GitHubIssueOutputSchema),
-    pullRequests: z.array(GitHubPullRequestOutputSchema),
-    issueCount: z.number(),
-    prCount: z.number(),
-    error: z.string().optional(),
-})
-
-/**
- * Kanban item schema.
- */
-const KanbanItemOutputSchema = z.object({
-    id: z.string(),
-    title: z.string(),
-    url: z.string(),
-    type: z.enum(['ISSUE', 'PULL_REQUEST', 'DRAFT_ISSUE']),
-    status: z.string().nullable(),
-    number: z.number().optional(),
-    labels: z.array(z.string()).optional(),
-    assignees: z.array(z.string()).optional(),
-    createdAt: z.string(),
-    updatedAt: z.string(),
-})
-
-/**
- * Status option schema.
- */
-const StatusOptionOutputSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    color: z.string().optional(),
-})
-
-/**
- * Kanban column schema.
- */
-const KanbanColumnOutputSchema = z.object({
-    status: z.string(),
-    statusOptionId: z.string(),
-    items: z.array(KanbanItemOutputSchema),
-})
-
-/**
- * Schema for get_kanban_board output.
- */
-const KanbanBoardOutputSchema = z.object({
-    projectId: z.string(),
-    projectNumber: z.number(),
-    projectTitle: z.string(),
-    statusFieldId: z.string(),
-    statusOptions: z.array(StatusOptionOutputSchema),
-    columns: z.array(KanbanColumnOutputSchema),
-    totalItems: z.number(),
-    owner: z.string().optional(),
-    detectedOwner: z.string().nullable().optional(),
-    detectedRepo: z.string().nullable().optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    hint: z.string().optional(),
-    instruction: z.string().optional(),
-})
-
-// ============================================================================
-// Phase 3b: Repository Insights Output Schema
-// ============================================================================
-
-/**
- * Schema for get_repo_insights output.
- * Uses optional sections to minimize token usage.
- */
-const RepoInsightsOutputSchema = z.object({
-    owner: z.string().optional(),
-    repo: z.string().optional(),
-    section: z.string().optional(),
-    stars: z.number().optional(),
-    forks: z.number().optional(),
-    watchers: z.number().optional(),
-    openIssues: z.number().optional(),
-    size: z.number().optional(),
-    defaultBranch: z.string().optional(),
-    traffic: z
-        .object({
-            clones: z.object({
-                total: z.number(),
-                unique: z.number(),
-                dailyAvg: z.number(),
-            }),
-            views: z.object({
-                total: z.number(),
-                unique: z.number(),
-                dailyAvg: z.number(),
-            }),
-            period: z.string(),
-        })
-        .optional(),
-    referrers: z
-        .array(
-            z.object({
-                referrer: z.string(),
-                count: z.number(),
-                uniques: z.number(),
-            })
-        )
-        .optional(),
-    paths: z
-        .array(
-            z.object({
-                path: z.string(),
-                title: z.string(),
-                count: z.number(),
-                uniques: z.number(),
-            })
-        )
-        .optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-// ============================================================================
-// Phase 4: Backup Tool Output Schemas
-// ============================================================================
-
-/**
- * Schema for backup_journal output.
- */
-const BackupResultOutputSchema = z.object({
-    success: z.boolean(),
-    message: z.string(),
-    filename: z.string(),
-    path: z.string(),
-    sizeBytes: z.number(),
-})
-
-/**
- * Backup info schema.
- */
-const BackupInfoOutputSchema = z.object({
-    filename: z.string(),
-    path: z.string(),
-    sizeBytes: z.number(),
-    createdAt: z.string(),
-})
-
-/**
- * Schema for list_backups output.
- */
-const BackupsListOutputSchema = z.object({
-    backups: z.array(BackupInfoOutputSchema),
-    total: z.number(),
-    backupsDirectory: z.string(),
-    hint: z.string().optional(),
-})
-
-/**
- * Schema for restore_backup output.
- */
-const RestoreResultOutputSchema = z.object({
-    success: z.boolean(),
-    message: z.string(),
-    restoredFrom: z.string(),
-    previousEntryCount: z.number(),
-    newEntryCount: z.number(),
-    warning: z.string().optional(),
-    revertedChanges: z
-        .object({
-            tagMerges: z.string().optional(),
-            entries: z.string().optional(),
-            relationships: z.string().optional(),
-        })
-        .optional(),
-})
-
-// ============================================================================
-// Phase 5: Remaining Tool Output Schemas
-// ============================================================================
-
-/**
- * Schema for test_simple output.
- */
-const TestSimpleOutputSchema = z.object({
-    message: z.string(),
-})
-
-/**
- * Schema for export_entries output.
- */
-const ExportEntriesOutputSchema = z.object({
-    format: z.enum(['json', 'markdown']),
-    entries: z.array(EntryOutputSchema).optional(), // For JSON format
-    content: z.string().optional(), // For markdown format
-})
-
-/**
- * Schema for rebuild_vector_index output.
- */
-const RebuildVectorIndexOutputSchema = z.object({
-    success: z.boolean(),
-    entriesIndexed: z.number(),
-    error: z.string().optional(),
-})
-
-/**
- * Schema for add_to_vector_index output.
- */
-const AddToVectorIndexOutputSchema = z.object({
-    success: z.boolean(),
-    entryId: z.number(),
-    error: z.string().optional(),
-})
-
-/**
- * Schema for move_kanban_item output.
- */
-const MoveKanbanItemOutputSchema = z.object({
-    success: z.boolean().optional(),
-    itemId: z.string().optional(),
-    newStatus: z.string().optional(),
-    projectNumber: z.number().optional(),
-    message: z.string().optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    hint: z.string().optional(),
-})
-
-/**
- * Schema for create_github_issue_with_entry output.
- */
-const CreateGitHubIssueWithEntryOutputSchema = z.object({
-    success: z.boolean().optional(),
-    issue: z
-        .object({
-            number: z.number(),
-            title: z.string(),
-            url: z.string(),
-        })
-        .optional(),
-    project: z
-        .object({
-            projectNumber: z.number(),
-            added: z.boolean(),
-            message: z.string(),
-            initialStatus: z
-                .object({
-                    status: z.string(),
-                    set: z.boolean(),
-                })
-                .optional(),
-        })
-        .optional(),
-    journalEntry: z
-        .object({
-            id: z.number(),
-            linkedToIssue: z.number(),
-        })
-        .optional(),
-    message: z.string().optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-/**
- * Schema for close_github_issue_with_entry output.
- */
-const CloseGitHubIssueWithEntryOutputSchema = z.object({
-    success: z.boolean().optional(),
-    issue: z
-        .object({
-            number: z.number(),
-            title: z.string(),
-            url: z.string(),
-            previousState: z.string(),
-            newState: z.string(),
-        })
-        .optional(),
-    journalEntry: z
-        .object({
-            id: z.number(),
-            linkedToIssue: z.number(),
-            significanceType: z.string(),
-        })
-        .optional(),
-    kanban: z
-        .object({
-            moved: z.boolean(),
-            projectNumber: z.number(),
-            message: z.string().optional(),
-        })
-        .optional(),
-    message: z.string().optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-// ============================================================================
-// GitHub Milestone Output Schemas
-// ============================================================================
-
-/**
- * GitHub milestone schema.
- */
-const GitHubMilestoneOutputSchema = z.object({
-    number: z.number(),
-    title: z.string(),
-    description: z.string().nullable(),
-    state: z.enum(['open', 'closed']),
-    url: z.string(),
-    dueOn: z.string().nullable(),
-    openIssues: z.number(),
-    closedIssues: z.number(),
-    completionPercentage: z.number().optional(),
-    createdAt: z.string(),
-    updatedAt: z.string(),
-    creator: z.string().nullable(),
-})
-
-/**
- * Schema for get_github_milestones output.
- */
-const GitHubMilestonesListOutputSchema = z.object({
-    owner: z.string().optional(),
-    repo: z.string().optional(),
-    detectedOwner: z.string().nullable().optional(),
-    detectedRepo: z.string().nullable().optional(),
-    milestones: z.array(GitHubMilestoneOutputSchema).optional(),
-    count: z.number().optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-/**
- * Schema for get_github_milestone output.
- */
-const GitHubMilestoneResultOutputSchema = z.object({
-    milestone: GitHubMilestoneOutputSchema.optional(),
-    owner: z.string().optional(),
-    repo: z.string().optional(),
-    detectedOwner: z.string().nullable().optional(),
-    detectedRepo: z.string().nullable().optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-/**
- * Schema for create_github_milestone output.
- */
-const CreateMilestoneOutputSchema = z.object({
-    success: z.boolean().optional(),
-    milestone: GitHubMilestoneOutputSchema.optional(),
-    message: z.string().optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-/**
- * Schema for update_github_milestone output.
- */
-const UpdateMilestoneOutputSchema = z.object({
-    success: z.boolean().optional(),
-    milestone: GitHubMilestoneOutputSchema.optional(),
-    message: z.string().optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-/**
- * Schema for delete_github_milestone output.
- */
-const DeleteMilestoneOutputSchema = z.object({
-    success: z.boolean().optional(),
-    milestoneNumber: z.number().optional(),
-    message: z.string().optional(),
-    error: z.string().optional(),
-    requiresUserInput: z.boolean().optional(),
-    instruction: z.string().optional(),
-})
-
-/**
- * Schema for cleanup_backups output.
- */
-const CleanupBackupsOutputSchema = z.object({
-    success: z.boolean(),
-    deleted: z.array(z.string()),
-    deletedCount: z.number(),
-    keptCount: z.number(),
-    message: z.string(),
-})
-
-// ============================================================================
-// Tool Definitions with MCP 2025-11-25 Annotations
-// ============================================================================
-
-/**
- * Get all tool definitions
+ * Get all tool definitions, optionally filtered by config
  */
 export function getTools(
     db: SqliteAdapter,
     filterConfig: ToolFilterConfig | null,
     vectorManager?: VectorSearchManager,
     github?: GitHubIntegration,
-    config?: ToolHandlerConfig
+    config?: ToolHandlerConfig,
+    teamDb?: SqliteAdapter
 ): object[] {
-    const context: ToolContext = { db, vectorManager, github, config }
+    const context: ToolContext = { db, teamDb, vectorManager, github, config }
     const allTools = getAllToolDefinitions(context)
 
-    // Filter if config provided
-    if (filterConfig) {
-        return allTools
-            .filter((t) => filterConfig.enabledTools.has(t.name))
-            .map((t) => ({
-                name: t.name,
-                description: t.description,
-                inputSchema: t.inputSchema,
-                outputSchema: t.outputSchema, // MCP 2025-11-25
-                annotations: t.annotations,
-                icons: getToolIcon(t.group), // MCP 2025-11-25 icons
-            }))
-    }
-
-    return allTools.map((t) => ({
+    const mapTool = (t: ToolDefinition): object => ({
         name: t.name,
         description: t.description,
         inputSchema: t.inputSchema,
-        outputSchema: t.outputSchema, // MCP 2025-11-25
+        outputSchema: t.outputSchema,
         annotations: t.annotations,
-        icons: getToolIcon(t.group), // MCP 2025-11-25 icons
-    }))
+        icons: getToolIcon(t.group),
+    })
+
+    if (filterConfig) {
+        return allTools.filter((t) => filterConfig.enabledTools.has(t.name)).map(mapTool)
+    }
+
+    return allTools.map(mapTool)
 }
 
+/**
+ * Cached tool map for O(1) lookup in callTool.
+ * Built lazily on first callTool invocation. Invalidates when any
+ * context parameter changes (happens in tests with different mocks;
+ * in production, all instances are stable).
+ */
+let toolMapCache: Map<string, ToolDefinition> | null = null
+let cachedContextRefs: {
+    db: SqliteAdapter
+    github?: GitHubIntegration
+    vectorManager?: VectorSearchManager
+    config?: ToolHandlerConfig
+    teamDb?: SqliteAdapter
+} | null = null
+
 /**
  * Call a tool by name
  */
-export async function callTool(
+export function callTool(
     name: string,
     args: Record<string, unknown>,
     db: SqliteAdapter,
     vectorManager?: VectorSearchManager,
     github?: GitHubIntegration,
     config?: ToolHandlerConfig,
-    progress?: ProgressContext
+    progress?: ProgressContext,
+    teamDb?: SqliteAdapter
 ): Promise<unknown> {
-    const context: ToolContext = { db, vectorManager, github, config, progress }
-    const tools = getAllToolDefinitions(context)
-    const tool = tools.find((t) => t.name === name)
+    const context: ToolContext = { db, teamDb, vectorManager, github, config, progress }
+
+    // Build tool map cache on first invocation or when context changes
+    if (
+        !toolMapCache ||
+        cachedContextRefs?.db !== db ||
+        cachedContextRefs.github !== github ||
+        cachedContextRefs.vectorManager !== vectorManager ||
+        cachedContextRefs.config !== config ||
+        cachedContextRefs.teamDb !== teamDb
+    ) {
+        toolMapCache = new Map(getAllToolDefinitions(context).map((t) => [t.name, t]))
+        cachedContextRefs = { db, github, vectorManager, config, teamDb }
+    }
+
+    const tool = toolMapCache.get(name)
 
     if (!tool) {
-        throw new Error(`Unknown tool: ${name}`)
+        return Promise.reject(new Error(`Unknown tool: ${name}`))
     }
 
-    return tool.handler(args)
+    return Promise.resolve(tool.handler(args))
 }
 
 /**
- * Get all tool definitions
+ * Compose all tool definitions from group modules
  */
 function getAllToolDefinitions(context: ToolContext): ToolDefinition[] {
-    const { db, vectorManager, github, progress } = context
     return [
-        // Core tools
-        {
-            name: 'create_entry',
-            title: 'Create Journal Entry',
-            description:
-                'Create a new journal entry with context and tags (v2.1.0: GitHub Actions support)',
-            group: 'core',
-            inputSchema: CreateEntrySchema,
-            outputSchema: CreateEntryOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false },
-            handler: (params: unknown) => {
-                const input = CreateEntrySchema.parse(params)
-
-                // Auto-populate issueUrl if issue_number provided without issueUrl
-                let resolvedIssueUrl = input.issue_url
-                if (input.issue_number !== undefined && !input.issue_url && github) {
-                    const cachedRepo = github.getCachedRepoInfo()
-                    if (cachedRepo?.owner && cachedRepo?.repo) {
-                        resolvedIssueUrl = `https://github.com/${cachedRepo.owner}/${cachedRepo.repo}/issues/${String(input.issue_number)}`
-                    }
-                }
-
-                const entry = db.createEntry({
-                    content: input.content,
-                    entryType: input.entry_type as EntryType,
-                    tags: input.tags,
-                    isPersonal: input.is_personal,
-                    significanceType: (input.significance_type as SignificanceType) ?? null,
-                    projectNumber: input.project_number,
-                    projectOwner: input.project_owner,
-                    issueNumber: input.issue_number,
-                    issueUrl: resolvedIssueUrl,
-                    prNumber: input.pr_number,
-                    prUrl: input.pr_url,
-                    prStatus: input.pr_status,
-                    workflowRunId: input.workflow_run_id,
-                    workflowName: input.workflow_name,
-                    workflowStatus: input.workflow_status,
-                })
-
-                // Auto-index to vector store for semantic search (fire-and-forget)
-                if (vectorManager) {
-                    vectorManager.addEntry(entry.id, entry.content).catch(() => {
-                        // Non-critical failure, entry already saved to DB
-                    })
-                }
-
-                return Promise.resolve({ success: true, entry })
-            },
-        },
-        {
-            name: 'get_entry_by_id',
-            title: 'Get Entry by ID',
-            description: 'Get a specific journal entry by ID with full details',
-            group: 'core',
-            inputSchema: GetEntryByIdSchema,
-            outputSchema: EntryByIdOutputSchema, // MCP 2025-11-25: structured output
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: (params: unknown) => {
-                const { entry_id, include_relationships } = GetEntryByIdSchema.parse(params)
-                const entry = db.getEntryById(entry_id)
-                if (!entry) {
-                    return Promise.resolve({ error: `Entry ${entry_id} not found` })
-                }
-                const { score: importance, breakdown: importanceBreakdown } =
-                    db.calculateImportance(entry_id)
-                const result: Record<string, unknown> = {
-                    entry,
-                    importance,
-                    importanceBreakdown,
-                }
-                if (include_relationships) {
-                    result['relationships'] = db.getRelationships(entry_id)
-                }
-                return Promise.resolve(result)
-            },
-        },
-        {
-            name: 'get_recent_entries',
-            title: 'Get Recent Entries',
-            description: 'Get recent journal entries',
-            group: 'core',
-            inputSchema: GetRecentEntriesSchema,
-            outputSchema: EntriesListOutputSchema, // MCP 2025-11-25: structured output
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: (params: unknown) => {
-                const { limit, is_personal } = GetRecentEntriesSchema.parse(params)
-                const entries = db.getRecentEntries(limit, is_personal)
-                return Promise.resolve({ entries, count: entries.length })
-            },
-        },
-        {
-            name: 'create_entry_minimal',
-            title: 'Create Entry (Minimal)',
-            description: 'Minimal entry creation without context or tags',
-            group: 'core',
-            inputSchema: CreateEntryMinimalSchema,
-            outputSchema: CreateEntryOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false },
-            handler: (params: unknown) => {
-                const { content } = CreateEntryMinimalSchema.parse(params)
-                const entry = db.createEntry({ content })
-
-                // Auto-index to vector store for semantic search (fire-and-forget)
-                if (vectorManager) {
-                    vectorManager.addEntry(entry.id, entry.content).catch(() => {
-                        // Non-critical failure, entry already saved to DB
-                    })
-                }
-
-                return Promise.resolve({ success: true, entry })
-            },
-        },
-        {
-            name: 'test_simple',
-            title: 'Test Simple',
-            description: 'Simple test tool that just returns a message',
-            group: 'core',
-            inputSchema: TestSimpleSchema,
-            outputSchema: TestSimpleOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: (params: unknown) => {
-                const { message } = TestSimpleSchema.parse(params)
-                return Promise.resolve({ message: `Test response: ${message}` })
-            },
-        },
-        // Search tools
-        {
-            name: 'search_entries',
-            title: 'Search Entries',
-            description:
-                'Search journal entries with optional filters for GitHub Projects, Issues, PRs, and Actions',
-            group: 'search',
-            inputSchema: SearchEntriesSchema,
-            outputSchema: EntriesListOutputSchema, // MCP 2025-11-25: structured output
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: (params: unknown) => {
-                const input = SearchEntriesSchema.parse(params)
-                // If no query and no filters, validation error usage of getRecentEntries
-                // But we want to allow filtering without text query
-                const hasFilters =
-                    input.project_number !== undefined ||
-                    input.issue_number !== undefined ||
-                    input.pr_number !== undefined ||
-                    input.is_personal !== undefined
-
-                if (!input.query && !hasFilters) {
-                    const entries = db.getRecentEntries(input.limit, input.is_personal)
-                    return Promise.resolve({ entries, count: entries.length })
-                }
-
-                const entries = db.searchEntries(input.query || '', {
-                    limit: input.limit,
-                    isPersonal: input.is_personal,
-                    projectNumber: input.project_number,
-                    issueNumber: input.issue_number,
-                    prNumber: input.pr_number,
-                })
-                return Promise.resolve({ entries, count: entries.length })
-            },
-        },
-        {
-            name: 'search_by_date_range',
-            title: 'Search by Date Range',
-            description: 'Search journal entries within a date range with optional filters',
-            group: 'search',
-            inputSchema: SearchByDateRangeSchema,
-            outputSchema: EntriesListOutputSchema, // MCP 2025-11-25: structured output
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: (params: unknown) => {
-                const input = SearchByDateRangeSchema.parse(params)
-                const entries = db.searchByDateRange(input.start_date, input.end_date, {
-                    entryType: input.entry_type as EntryType | undefined,
-                    tags: input.tags,
-                    isPersonal: input.is_personal,
-                    projectNumber: input.project_number,
-                })
-                return Promise.resolve({ entries, count: entries.length })
-            },
-        },
-        {
-            name: 'semantic_search',
-            title: 'Semantic Search',
-            description: 'Perform semantic/vector search on journal entries using AI embeddings',
-            group: 'search',
-            inputSchema: SemanticSearchSchema,
-            outputSchema: SemanticSearchOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: async (params: unknown) => {
-                const input = SemanticSearchSchema.parse(params)
-
-                // Check if vector search is available
-                if (!vectorManager) {
-                    return {
-                        error: 'Semantic search not initialized. Vector search manager is not available.',
-                        query: input.query,
-                        entries: [],
-                        count: 0,
-                    }
-                }
-
-                // Perform semantic search
-                const results = await vectorManager.search(
-                    input.query,
-                    input.limit ?? 10,
-                    input.similarity_threshold ?? 0.25
-                )
-
-                // Fetch full entries for matching IDs
-                const entries = results
-                    .map((r) => {
-                        const entry = db.getEntryById(r.entryId)
-                        if (!entry) return null
-                        return {
-                            ...entry,
-                            similarity: Math.round(r.score * 100) / 100,
-                        }
-                    })
-                    .filter((e): e is NonNullable<typeof e> => e !== null)
-
-                // Check index stats to provide accurate hint
-                const stats = await vectorManager.getStats()
-                const isIndexEmpty = stats.itemCount === 0
-
-                // hint_on_empty controls whether to show helpful hints (default: true)
-                const includeHint = input.hint_on_empty ?? true
-
-                return {
-                    query: input.query,
-                    entries,
-                    count: entries.length,
-                    ...(includeHint && isIndexEmpty
-                        ? {
-                              hint: 'No entries in vector index. Use rebuild_vector_index to index existing entries.',
-                          }
-                        : includeHint && entries.length === 0
-                          ? {
-                                hint: `No entries matched your query above the similarity threshold (${String(input.similarity_threshold ?? 0.25)}). Try lowering similarity_threshold (e.g., 0.15) for broader matches.`,
-                            }
-                          : {}),
-                }
-            },
-        },
-        // Analytics tools
-        {
-            name: 'get_statistics',
-            title: 'Get Statistics',
-            description:
-                'Get journal statistics and analytics (Phase 2: includes project breakdown)',
-            group: 'analytics',
-            inputSchema: GetStatisticsSchema,
-            outputSchema: StatisticsOutputSchema, // MCP 2025-11-25: structured output
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: (params: unknown) => {
-                const { group_by } = GetStatisticsSchema.parse(params)
-                const stats = db.getStatistics(group_by)
-                return Promise.resolve({ ...stats, groupBy: group_by })
-            },
-        },
-        {
-            name: 'get_cross_project_insights',
-            title: 'Get Cross-Project Insights',
-            description: 'Analyze patterns across all GitHub Projects tracked in journal entries',
-            group: 'analytics',
-            inputSchema: z.object({
-                start_date: z.string().optional().describe('Start date (YYYY-MM-DD)'),
-                end_date: z.string().optional().describe('End date (YYYY-MM-DD)'),
-                min_entries: z
-                    .number()
-                    .optional()
-                    .default(3)
-                    .describe('Minimum entries to include project'),
-            }),
-            outputSchema: CrossProjectInsightsOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: (params: unknown) => {
-                const input = z
-                    .object({
-                        start_date: z.string().optional(),
-                        end_date: z.string().optional(),
-                        min_entries: z.number().optional().default(3),
-                    })
-                    .parse(params)
-
-                const rawDb = db.getRawDb()
-
-                // Build WHERE clause
-                let where = 'WHERE deleted_at IS NULL AND project_number IS NOT NULL'
-                const sqlParams: unknown[] = []
-
-                if (input.start_date) {
-                    where += ' AND DATE(timestamp) >= DATE(?)'
-                    sqlParams.push(input.start_date)
-                }
-                if (input.end_date) {
-                    where += ' AND DATE(timestamp) <= DATE(?)'
-                    sqlParams.push(input.end_date)
-                }
-
-                // Get active projects with stats
-                const projectsResult = rawDb.exec(
-                    `
-                    SELECT project_number, COUNT(*) as entry_count,
-                           MIN(DATE(timestamp)) as first_entry,
-                           MAX(DATE(timestamp)) as last_entry,
-                           COUNT(DISTINCT DATE(timestamp)) as active_days
-                    FROM memory_journal ${where}
-                    GROUP BY project_number
-                    HAVING entry_count >= ?
-                    ORDER BY entry_count DESC
-                `,
-                    [...sqlParams, input.min_entries]
-                )
-
-                if (!projectsResult[0] || projectsResult[0].values.length === 0) {
-                    return Promise.resolve({
-                        project_count: 0,
-                        total_entries: 0,
-                        projects: [],
-                        inactive_projects: [],
-                        inactiveThresholdDays: 7,
-                        time_distribution: [],
-                        message: `No projects found with at least ${String(input.min_entries)} entries`,
-                    })
-                }
-
-                const columns = projectsResult[0].columns
-                const projects = projectsResult[0].values.map((row) => {
-                    const obj: Record<string, unknown> = {}
-                    columns.forEach((col, i) => {
-                        obj[col] = row[i]
-                    })
-                    return obj
-                })
-
-                // Get top tags per project
-                const projectTags: Record<number, { name: string; count: number }[]> = {}
-                for (const proj of projects) {
-                    const projNum = proj['project_number'] as number
-                    const tagsResult = rawDb.exec(
-                        `
-                        SELECT t.name, COUNT(*) as count
-                        FROM tags t
-                        JOIN entry_tags et ON t.id = et.tag_id
-                        JOIN memory_journal m ON et.entry_id = m.id
-                        WHERE m.project_number = ? AND m.deleted_at IS NULL
-                        GROUP BY t.name
-                        ORDER BY count DESC
-                        LIMIT 5
-                    `,
-                        [projNum]
-                    )
-                    if (tagsResult[0]) {
-                        projectTags[projNum] = tagsResult[0].values.map((row) => ({
-                            name: row[0] as string,
-                            count: row[1] as number,
-                        }))
-                    }
-                }
-
-                // Find inactive projects (last entry > 7 days ago)
-                const cutoffDate = new Date(Date.now() - 7 * 86400000).toISOString().split('T')[0]
-                const inactiveResult = rawDb.exec(
-                    `
-                    SELECT project_number, MAX(DATE(timestamp)) as last_entry_date
-                    FROM memory_journal
-                    WHERE deleted_at IS NULL AND project_number IS NOT NULL
-                    GROUP BY project_number
-                    HAVING last_entry_date < ?
-                `,
-                    [cutoffDate]
-                )
-
-                const inactiveProjects =
-                    inactiveResult[0]?.values.map((row) => ({
-                        project_number: row[0] as number,
-                        last_entry_date: row[1] as string,
-                    })) ?? []
-
-                // Calculate time distribution
-                const totalEntries = projects.reduce(
-                    (sum, p) => sum + (p['entry_count'] as number),
-                    0
-                )
-                const distribution = projects.slice(0, 5).map((p) => ({
-                    project_number: p['project_number'],
-                    percentage: (((p['entry_count'] as number) / totalEntries) * 100).toFixed(1),
-                }))
-
-                return Promise.resolve({
-                    project_count: projects.length,
-                    total_entries: totalEntries,
-                    projects: projects.map((p) => ({
-                        ...p,
-                        top_tags: projectTags[p['project_number'] as number] ?? [],
-                    })),
-                    inactive_projects: inactiveProjects,
-                    inactiveThresholdDays: 7,
-                    time_distribution: distribution,
-                })
-            },
-        },
-        // Relationship tools
-        {
-            name: 'link_entries',
-            title: 'Link Entries',
-            description: 'Create a relationship between two journal entries',
-            group: 'relationships',
-            inputSchema: LinkEntriesSchema,
-            outputSchema: LinkEntriesOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false },
-            handler: (params: unknown) => {
-                const input = LinkEntriesSchema.parse(params)
-
-                // Check for existing duplicate relationship
-                const existingRelationships = db.getRelationships(input.from_entry_id)
-                const existing = existingRelationships.find(
-                    (r) =>
-                        r.toEntryId === input.to_entry_id &&
-                        r.relationshipType === input.relationship_type
-                )
-
-                if (existing) {
-                    return Promise.resolve({
-                        success: true,
-                        relationship: existing,
-                        duplicate: true,
-                        message: 'Relationship already exists',
-                    })
-                }
-
-                // P154: linkEntries throws for nonexistent entries
-                try {
-                    const relationship = db.linkEntries(
-                        input.from_entry_id,
-                        input.to_entry_id,
-                        input.relationship_type as RelationshipType,
-                        input.description
-                    )
-                    return Promise.resolve({ success: true, relationship })
-                } catch (error) {
-                    return Promise.resolve({
-                        success: false,
-                        relationship: {
-                            id: 0,
-                            fromEntryId: input.from_entry_id,
-                            toEntryId: input.to_entry_id,
-                            relationshipType: input.relationship_type,
-                            description: input.description ?? null,
-                            createdAt: '',
-                        },
-                        message: error instanceof Error ? error.message : 'Unknown error',
-                    })
-                }
-            },
-        },
-        {
-            name: 'visualize_relationships',
-            title: 'Visualize Relationships',
-            description: 'Generate a Mermaid diagram visualization of entry relationships',
-            group: 'relationships',
-            inputSchema: z.object({
-                entry_id: z
-                    .number()
-                    .optional()
-                    .describe('Specific entry ID to visualize (shows connected entries)'),
-                tags: z.array(z.string()).optional().describe('Filter entries by tags'),
-                depth: z
-                    .number()
-                    .min(1)
-                    .max(3)
-                    .optional()
-                    .default(2)
-                    .describe('Relationship traversal depth'),
-                limit: z.number().optional().default(20).describe('Maximum entries to include'),
-            }),
-            outputSchema: VisualizationOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: (params: unknown) => {
-                const input = z
-                    .object({
-                        entry_id: z.number().optional(),
-                        tags: z.array(z.string()).optional(),
-                        depth: z.number().optional().default(2),
-                        limit: z.number().optional().default(20),
-                    })
-                    .parse(params)
-
-                const rawDb = db.getRawDb()
-                let entriesResult
-
-                if (input.entry_id !== undefined) {
-                    // P154: Pre-check entry existence to disambiguate responses
-                    const entry = db.getEntryById(input.entry_id)
-                    if (!entry) {
-                        return Promise.resolve({
-                            entry_count: 0,
-                            relationship_count: 0,
-                            root_entry: input.entry_id,
-                            depth: input.depth,
-                            mermaid: null,
-                            message: `Entry ${String(input.entry_id)} not found`,
-                        })
-                    }
-
-                    // Use recursive CTE to get connected entries up to depth
-                    entriesResult = rawDb.exec(
-                        `
-                        WITH RECURSIVE connected_entries(id, distance) AS (
-                            SELECT id, 0 FROM memory_journal WHERE id = ? AND deleted_at IS NULL
-                            UNION
-                            SELECT DISTINCT
-                                CASE
-                                    WHEN r.from_entry_id = ce.id THEN r.to_entry_id
-                                    ELSE r.from_entry_id
-                                END,
-                                ce.distance + 1
-                            FROM connected_entries ce
-                            JOIN relationships r ON r.from_entry_id = ce.id OR r.to_entry_id = ce.id
-                            WHERE ce.distance < ?
-                        )
-                        SELECT DISTINCT mj.id, mj.entry_type, mj.content, mj.is_personal
-                        FROM memory_journal mj
-                        JOIN connected_entries ce ON mj.id = ce.id
-                        WHERE mj.deleted_at IS NULL
-                        LIMIT ?
-                    `,
-                        [input.entry_id, input.depth, input.limit]
-                    )
-                } else if (input.tags && input.tags.length > 0) {
-                    // Filter by tags
-                    const placeholders = input.tags.map(() => '?').join(',')
-                    entriesResult = rawDb.exec(
-                        `
-                        SELECT DISTINCT mj.id, mj.entry_type, mj.content, mj.is_personal
-                        FROM memory_journal mj
-                        WHERE mj.deleted_at IS NULL
-                          AND mj.id IN (
-                              SELECT et.entry_id FROM entry_tags et
-                              JOIN tags t ON et.tag_id = t.id
-                              WHERE t.name IN (${placeholders})
-                          )
-                        LIMIT ?
-                    `,
-                        [...input.tags, input.limit]
-                    )
-                } else {
-                    // Get recent entries with relationships
-                    entriesResult = rawDb.exec(
-                        `
-                        SELECT DISTINCT mj.id, mj.entry_type, mj.content, mj.is_personal
-                        FROM memory_journal mj
-                        WHERE mj.deleted_at IS NULL
-                          AND mj.id IN (
-                              SELECT DISTINCT from_entry_id FROM relationships
-                              UNION
-                              SELECT DISTINCT to_entry_id FROM relationships
-                          )
-                        ORDER BY mj.id DESC
-                        LIMIT ?
-                    `,
-                        [input.limit]
-                    )
-                }
-
-                if (!entriesResult[0] || entriesResult[0].values.length === 0) {
-                    return Promise.resolve({
-                        entry_count: 0,
-                        relationship_count: 0,
-                        root_entry: input.entry_id ?? null,
-                        depth: input.depth,
-                        mermaid: null,
-                        message: 'No entries found with relationships matching your criteria',
-                    })
-                }
-
-                // Build entries map
-                const entries: Record<
-                    number,
-                    { id: number; entry_type: string; content: string; is_personal: boolean }
-                > = {}
-                const cols = entriesResult[0].columns
-                for (const row of entriesResult[0].values) {
-                    const id = row[cols.indexOf('id')] as number
-                    entries[id] = {
-                        id,
-                        entry_type: row[cols.indexOf('entry_type')] as string,
-                        content: row[cols.indexOf('content')] as string,
-                        is_personal: Boolean(row[cols.indexOf('is_personal')]),
-                    }
-                }
-
-                const entryIds = Object.keys(entries).map(Number)
-                const placeholders = entryIds.map(() => '?').join(',')
-
-                // Get relationships between these entries
-                const relsResult = rawDb.exec(
-                    `
-                    SELECT from_entry_id, to_entry_id, relationship_type
-                    FROM relationships
-                    WHERE from_entry_id IN (${placeholders})
-                      AND to_entry_id IN (${placeholders})
-                `,
-                    [...entryIds, ...entryIds]
-                )
-
-                const relationships = relsResult[0]?.values ?? []
-
-                // Generate Mermaid diagram
-                let mermaid = '```mermaid\\ngraph TD\\n'
-
-                // Add nodes
-                for (const [idStr, entry] of Object.entries(entries)) {
-                    let contentPreview = entry.content.slice(0, 40).replace(/\\n/g, ' ')
-                    if (entry.content.length > 40) contentPreview += '...'
-                    // Escape for Mermaid
-                    contentPreview = contentPreview
-                        .replace(/"/g, "'")
-                        .replace(/\\[/g, '(').replace(/\\]/g, ')')
-                    const entryTypeShort = entry.entry_type.slice(0, 20)
-                    mermaid += `    E${idStr}["#${idStr}: ${contentPreview}<br/>${entryTypeShort}"]\\n`
-                }
-
-                mermaid += '\\n'
-
-                // Add relationships with arrows
-                const relSymbols: Record<string, string> = {
-                    references: '-->',
-                    implements: '==>',
-                    clarifies: '-.->',
-                    evolves_from: '-->',
-                    response_to: '<-->',
-                    // Causal relationship types
-                    blocked_by: '--x',
-                    resolved: '==>',
-                    caused: '-.->',
-                }
-
-                for (const rel of relationships) {
-                    const fromId = rel[0] as number
-                    const toId = rel[1] as number
-                    const relType = rel[2] as string
-                    const arrow = relSymbols[relType] ?? '-->'
-                    mermaid += `    E${String(fromId)} ${arrow}|${relType}| E${String(toId)}\\n`
-                }
-
-                // Add styling
-                mermaid += '\\n'
-                for (const [idStr, entry] of Object.entries(entries)) {
-                    if (entry.is_personal) {
-                        mermaid += `    style E${idStr} fill:#E3F2FD\\n`
-                    } else {
-                        mermaid += `    style E${idStr} fill:#FFF3E0\\n`
-                    }
-                }
-                mermaid += '```'
-
-                return Promise.resolve({
-                    entry_count: Object.keys(entries).length,
-                    relationship_count: relationships.length,
-                    root_entry: input.entry_id ?? null,
-                    depth: input.depth,
-                    mermaid,
-                    legend: {
-                        blue: 'Personal entries',
-                        orange: 'Project entries',
-                        arrows: {
-                            '-->': 'references / evolves_from',
-                            '==>': 'implements / resolved',
-                            '-.->': 'clarifies / caused',
-                            '<-->': 'response_to',
-                            '--x': 'blocked_by',
-                        },
-                    },
-                })
-            },
-        },
-        // Export tools
-        {
-            name: 'export_entries',
-            title: 'Export Entries',
-            description: 'Export journal entries to JSON or Markdown format',
-            group: 'export',
-            inputSchema: ExportEntriesSchema,
-            outputSchema: ExportEntriesOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: async (params: unknown) => {
-                const input = ExportEntriesSchema.parse(params)
-                const limit = input.limit ?? 100
-
-                // Send initial progress
-                await sendProgress(progress, 0, 2, 'Fetching entries...')
-
-                const entries = db.getRecentEntries(limit)
-
-                // Send processing progress
-                await sendProgress(
-                    progress,
-                    1,
-                    2,
-                    `Processing ${String(entries.length)} entries...`
-                )
-
-                if (input.format === 'markdown') {
-                    const md = entries
-                        .map(
-                            (e) =>
-                                `## ${e.timestamp}\n\n**Type:** ${e.entryType}\n\n${e.content}\n\n---`
-                        )
-                        .join('\n\n')
-
-                    await sendProgress(progress, 2, 2, 'Export complete')
-                    return { format: 'markdown', content: md }
-                }
-
-                await sendProgress(progress, 2, 2, 'Export complete')
-                return { format: 'json', entries }
-            },
-        },
-        // Admin tools
-        {
-            name: 'update_entry',
-            title: 'Update Entry',
-            description: 'Update an existing journal entry',
-            group: 'admin',
-            inputSchema: UpdateEntrySchema,
-            outputSchema: UpdateEntryOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false },
-            handler: (params: unknown) => {
-                const input = UpdateEntrySchema.parse(params)
-                const entry = db.updateEntry(input.entry_id, {
-                    content: input.content,
-                    entryType: input.entry_type as EntryType | undefined,
-                    isPersonal: input.is_personal,
-                    tags: input.tags,
-                })
-                if (!entry) {
-                    return Promise.resolve({ error: `Entry ${input.entry_id} not found` })
-                }
-
-                // Re-index if content changed
-                if (input.content && vectorManager) {
-                    vectorManager.addEntry(entry.id, entry.content).catch(() => {
-                        // Non-critical failure, entry already updated in DB
-                    })
-                }
-
-                return Promise.resolve({ success: true, entry })
-            },
-        },
-        {
-            name: 'delete_entry',
-            title: 'Delete Entry',
-            description: 'Delete a journal entry (soft delete with timestamp)',
-            group: 'admin',
-            inputSchema: DeleteEntrySchema,
-            outputSchema: DeleteEntryOutputSchema,
-            annotations: { readOnlyHint: false, destructiveHint: true },
-            handler: (params: unknown) => {
-                const { entry_id, permanent } = DeleteEntrySchema.parse(params)
-                const success = db.deleteEntry(entry_id, permanent)
-
-                // P154: Surface structured error for nonexistent entries
-                if (!success) {
-                    return Promise.resolve({
-                        success: false,
-                        entryId: entry_id,
-                        permanent,
-                        error: `Entry ${String(entry_id)} not found`,
-                    })
-                }
-
-                // Remove from vector index (non-critical if fails)
-                if (vectorManager) {
-                    vectorManager.removeEntry(entry_id).catch(() => {
-                        // Non-critical failure, entry already deleted from DB
-                    })
-                }
-
-                return Promise.resolve({ success, entryId: entry_id, permanent })
-            },
-        },
-        // Utility tools
-        {
-            name: 'list_tags',
-            title: 'List Tags',
-            description: 'List all available tags',
-            group: 'core',
-            inputSchema: z.object({}),
-            outputSchema: TagsListOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: (_params: unknown) => {
-                const rawTags = db.listTags()
-                const tags = rawTags.map((t) => ({ name: t.name, count: t.usageCount }))
-                return Promise.resolve({ tags, count: tags.length })
-            },
-        },
-        {
-            name: 'merge_tags',
-            title: 'Merge Tags',
-            description:
-                'Merge one tag into another to consolidate similar tags (e.g., merge "phase-2" into "phase2"). The source tag is deleted after merge.',
-            group: 'admin',
-            inputSchema: z.object({
-                source_tag: z.string().min(1).describe('Tag to merge from (will be deleted)'),
-                target_tag: z
-                    .string()
-                    .min(1)
-                    .describe('Tag to merge into (will be created if not exists)'),
-            }),
-            outputSchema: MergeTagsOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false },
-            handler: (params: unknown) => {
-                const { source_tag, target_tag } = z
-                    .object({
-                        source_tag: z.string().min(1),
-                        target_tag: z.string().min(1),
-                    })
-                    .parse(params)
-
-                if (source_tag === target_tag) {
-                    return Promise.resolve({
-                        success: false,
-                        sourceTag: source_tag,
-                        targetTag: target_tag,
-                        entriesUpdated: 0,
-                        sourceDeleted: false,
-                        message: 'Source and target tags cannot be the same',
-                        error: 'Source and target tags must be different',
-                    })
-                }
-
-                try {
-                    const result = db.mergeTags(source_tag, target_tag)
-                    return Promise.resolve({
-                        success: true,
-                        sourceTag: source_tag,
-                        targetTag: target_tag,
-                        entriesUpdated: result.entriesUpdated,
-                        sourceDeleted: result.sourceDeleted,
-                        message: `Merged "${source_tag}" into "${target_tag}". Updated ${String(result.entriesUpdated)} entries.`,
-                    })
-                } catch (error) {
-                    return Promise.resolve({
-                        success: false,
-                        sourceTag: source_tag,
-                        targetTag: target_tag,
-                        entriesUpdated: 0,
-                        sourceDeleted: false,
-                        message: 'Tag merge failed',
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    })
-                }
-            },
-        },
-        // Vector index management tools
-        {
-            name: 'rebuild_vector_index',
-            title: 'Rebuild Vector Index',
-            description: 'Rebuild the semantic search vector index from all existing entries',
-            group: 'admin',
-            inputSchema: z.object({}),
-            outputSchema: RebuildVectorIndexOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false },
-            handler: async (_params: unknown) => {
-                if (!vectorManager) {
-                    return { error: 'Vector search not available' }
-                }
-                const indexed = await vectorManager.rebuildIndex(db, progress)
-                return { success: true, entriesIndexed: indexed }
-            },
-        },
-        {
-            name: 'add_to_vector_index',
-            title: 'Add Entry to Vector Index',
-            description: 'Add a specific entry to the semantic search vector index',
-            group: 'admin',
-            inputSchema: z.object({ entry_id: z.number() }),
-            outputSchema: AddToVectorIndexOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: true },
-            handler: async (params: unknown) => {
-                const { entry_id } = z.object({ entry_id: z.number() }).parse(params)
-                if (!vectorManager) {
-                    return { error: 'Vector search not available' }
-                }
-                const entry = db.getEntryById(entry_id)
-                if (!entry) {
-                    return { error: `Entry ${String(entry_id)} not found` }
-                }
-                const success = await vectorManager.addEntry(entry_id, entry.content)
-                return { success, entryId: entry_id }
-            },
-        },
-        {
-            name: 'get_vector_index_stats',
-            title: 'Get Vector Index Stats',
-            description: 'Get statistics about the semantic search vector index',
-            group: 'search',
-            inputSchema: z.object({}),
-            outputSchema: VectorStatsOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: async (_params: unknown) => {
-                if (!vectorManager) {
-                    return { available: false, error: 'Vector search not available' }
-                }
-                const stats = await vectorManager.getStats()
-                return { available: true, ...stats }
-            },
-        },
-        // GitHub integration tools
-        {
-            name: 'get_github_issues',
-            title: 'Get GitHub Issues',
-            description:
-                'List issues from a GitHub repository. IMPORTANT: Do NOT guess owner/repo values - leave them empty to auto-detect from the current git repository.',
-            group: 'github',
-            inputSchema: z.object({
-                owner: z
-                    .string()
-                    .optional()
-                    .describe(
-                        'Repository owner - LEAVE EMPTY to auto-detect from git. Only specify if user explicitly provides.'
-                    ),
-                repo: z
-                    .string()
-                    .optional()
-                    .describe(
-                        'Repository name - LEAVE EMPTY to auto-detect from git. Only specify if user explicitly provides.'
-                    ),
-                state: z.enum(['open', 'closed', 'all']).optional().default('open'),
-                limit: z.number().optional().default(20),
-            }),
-            outputSchema: GitHubIssuesListOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                        state: z.enum(['open', 'closed', 'all']).optional().default('open'),
-                        limit: z.number().optional().default(20),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                // Get owner/repo from input or from current repo
-                const repoInfo = await github.getRepoInfo()
-                const detectedOwner = repoInfo.owner
-                const detectedRepo = repoInfo.repo
-
-                const owner = input.owner ?? detectedOwner ?? undefined
-                const repo = input.repo ?? detectedRepo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS. You MUST ask the user to provide the GitHub owner and repository name.',
-                        requiresUserInput: true,
-                        detectedOwner,
-                        detectedRepo,
-                        instruction:
-                            'Ask the user: "What GitHub repository would you like to query? Please provide the owner and repo name (e.g., owner/repo)."',
-                    }
-                }
-
-                const issues = await github.getIssues(owner, repo, input.state, input.limit)
-                return { owner, repo, detectedOwner, detectedRepo, issues, count: issues.length }
-            },
-        },
-        {
-            name: 'get_github_prs',
-            title: 'Get GitHub Pull Requests',
-            description:
-                'List pull requests from a GitHub repository. IMPORTANT: Do NOT guess owner/repo values - leave them empty to auto-detect from the current git repository.',
-            group: 'github',
-            inputSchema: z.object({
-                owner: z
-                    .string()
-                    .optional()
-                    .describe(
-                        'Repository owner - LEAVE EMPTY to auto-detect from git. Only specify if user explicitly provides.'
-                    ),
-                repo: z
-                    .string()
-                    .optional()
-                    .describe(
-                        'Repository name - LEAVE EMPTY to auto-detect from git. Only specify if user explicitly provides.'
-                    ),
-                state: z.enum(['open', 'closed', 'all']).optional().default('open'),
-                limit: z.number().optional().default(20),
-            }),
-            outputSchema: GitHubPRsListOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                        state: z.enum(['open', 'closed', 'all']).optional().default('open'),
-                        limit: z.number().optional().default(20),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                const repoInfo = await github.getRepoInfo()
-                const detectedOwner = repoInfo.owner
-                const detectedRepo = repoInfo.repo
-
-                const owner = input.owner ?? detectedOwner ?? undefined
-                const repo = input.repo ?? detectedRepo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS. You MUST ask the user to provide the GitHub owner and repository name.',
-                        requiresUserInput: true,
-                        detectedOwner,
-                        detectedRepo,
-                        instruction:
-                            'Ask the user: "What GitHub repository would you like to query? Please provide the owner and repo name (e.g., owner/repo)."',
-                    }
-                }
-
-                const pullRequests = await github.getPullRequests(
-                    owner,
-                    repo,
-                    input.state,
-                    input.limit
-                )
-                return {
-                    owner,
-                    repo,
-                    detectedOwner,
-                    detectedRepo,
-                    pullRequests,
-                    count: pullRequests.length,
-                }
-            },
-        },
-        {
-            name: 'get_github_issue',
-            title: 'Get GitHub Issue Details',
-            description:
-                'Get detailed information about a specific GitHub issue. IMPORTANT: Do NOT guess owner/repo values - leave them empty to auto-detect from the current git repository.',
-            group: 'github',
-            inputSchema: z.object({
-                issue_number: z.number(),
-                owner: z.string().optional().describe('LEAVE EMPTY to auto-detect from git'),
-                repo: z.string().optional().describe('LEAVE EMPTY to auto-detect from git'),
-            }),
-            outputSchema: GitHubIssueResultOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        issue_number: z.number(),
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                const repoInfo = await github.getRepoInfo()
-                const detectedOwner = repoInfo.owner
-                const detectedRepo = repoInfo.repo
-
-                const owner = input.owner ?? detectedOwner ?? undefined
-                const repo = input.repo ?? detectedRepo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS. You MUST ask the user to provide the GitHub owner and repository name.',
-                        requiresUserInput: true,
-                        detectedOwner,
-                        detectedRepo,
-                        instruction:
-                            'Ask the user: "What GitHub repository is this issue from? Please provide the owner and repo name (e.g., owner/repo)."',
-                    }
-                }
-
-                const issue = await github.getIssue(owner, repo, input.issue_number)
-                if (!issue) {
-                    return {
-                        error: `Issue #${String(input.issue_number)} not found`,
-                        owner,
-                        repo,
-                        detectedOwner,
-                        detectedRepo,
-                    }
-                }
-                return { issue, owner, repo, detectedOwner, detectedRepo }
-            },
-        },
-        {
-            name: 'get_github_pr',
-            title: 'Get GitHub PR Details',
-            description:
-                'Get detailed information about a specific GitHub pull request. IMPORTANT: Do NOT guess owner/repo values - leave them empty to auto-detect from the current git repository.',
-            group: 'github',
-            inputSchema: z.object({
-                pr_number: z.number(),
-                owner: z.string().optional().describe('LEAVE EMPTY to auto-detect from git'),
-                repo: z.string().optional().describe('LEAVE EMPTY to auto-detect from git'),
-            }),
-            outputSchema: GitHubPRResultOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        pr_number: z.number(),
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                const repoInfo = await github.getRepoInfo()
-                const detectedOwner = repoInfo.owner
-                const detectedRepo = repoInfo.repo
-
-                const owner = input.owner ?? detectedOwner ?? undefined
-                const repo = input.repo ?? detectedRepo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS. You MUST ask the user to provide the GitHub owner and repository name.',
-                        requiresUserInput: true,
-                        detectedOwner,
-                        detectedRepo,
-                        instruction:
-                            'Ask the user: "What GitHub repository is this PR from? Please provide the owner and repo name (e.g., owner/repo)."',
-                    }
-                }
-
-                const pullRequest = await github.getPullRequest(owner, repo, input.pr_number)
-                if (!pullRequest) {
-                    return {
-                        error: `PR #${String(input.pr_number)} not found`,
-                        owner,
-                        repo,
-                        detectedOwner,
-                        detectedRepo,
-                    }
-                }
-                return { pullRequest, owner, repo, detectedOwner, detectedRepo }
-            },
-        },
-        {
-            name: 'get_github_context',
-            title: 'Get GitHub Repository Context',
-            description:
-                'Get current repository context including branch, open issues, and open PRs. Only counts OPEN items (closed items excluded).',
-            group: 'github',
-            inputSchema: z.object({}),
-            outputSchema: GitHubContextOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-            handler: async (_params: unknown) => {
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                const context = await github.getRepoContext()
-                return {
-                    repoName: context.repoName,
-                    branch: context.branch,
-                    commit: context.commit,
-                    remoteUrl: context.remoteUrl,
-                    issues: context.issues,
-                    pullRequests: context.pullRequests,
-                    issueCount: context.issues.length,
-                    prCount: context.pullRequests.length,
-                }
-            },
-        },
-        // Kanban tools (GitHub Projects v2)
-        {
-            name: 'get_kanban_board',
-            title: 'Get Kanban Board',
-            description:
-                'View a GitHub Project v2 as a Kanban board with items grouped by Status column. Returns all columns with their items.',
-            group: 'github',
-            inputSchema: z.object({
-                project_number: z.number().describe('GitHub Project number (from the project URL)'),
-                owner: z
-                    .string()
-                    .optional()
-                    .describe('Repository owner - LEAVE EMPTY to auto-detect from git'),
-            }),
-            outputSchema: KanbanBoardOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        project_number: z.number(),
-                        owner: z.string().optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                // Get owner from input or from current repo
-                const repoInfo = await github.getRepoInfo()
-                const detectedOwner = repoInfo.owner
-                const owner = input.owner ?? detectedOwner ?? undefined
-
-                if (!owner) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository owner. DO NOT GUESS. You MUST ask the user to provide the GitHub owner.',
-                        requiresUserInput: true,
-                        detectedOwner,
-                        instruction:
-                            'Ask the user: "What GitHub username or organization owns this project?"',
-                    }
-                }
-
-                const repo = repoInfo.repo ?? undefined
-                const board = await github.getProjectKanban(owner, input.project_number, repo)
-                if (!board) {
-                    return {
-                        error: `Project #${String(input.project_number)} not found or Status field not configured`,
-                        owner,
-                        repo,
-                        hint: 'Ensure the project exists and has a "Status" single-select field. Projects can be at user, repository, or organization level.',
-                    }
-                }
-
-                return {
-                    ...board,
-                    owner,
-                    detectedOwner,
-                    detectedRepo: repo,
-                }
-            },
-        },
-        {
-            name: 'move_kanban_item',
-            title: 'Move Kanban Item',
-            description:
-                'Move a project item to a different Status column. Use get_kanban_board first to get the item_id and exact status names. Status matching is case-insensitive.',
-            group: 'github',
-            inputSchema: z.object({
-                project_number: z.number().describe('GitHub Project number'),
-                item_id: z.string().describe('Project item node ID (from get_kanban_board)'),
-                target_status: z
-                    .string()
-                    .describe('Target status name (e.g., "Done", "In Progress")'),
-                owner: z
-                    .string()
-                    .optional()
-                    .describe('Repository owner - LEAVE EMPTY to auto-detect'),
-            }),
-            outputSchema: MoveKanbanItemOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        project_number: z.number(),
-                        item_id: z.string(),
-                        target_status: z.string(),
-                        owner: z.string().optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                // Get owner from input or from current repo
-                const repoInfo = await github.getRepoInfo()
-                const detectedOwner = repoInfo.owner
-                const owner = input.owner ?? detectedOwner ?? undefined
-
-                if (!owner) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository owner. DO NOT GUESS.',
-                        requiresUserInput: true,
-                    }
-                }
-
-                // First, get the board to find projectId, statusFieldId, and target statusOptionId
-                const repo = repoInfo.repo ?? undefined
-                const board = await github.getProjectKanban(owner, input.project_number, repo)
-                if (!board) {
-                    return {
-                        error: `Project #${String(input.project_number)} not found`,
-                    }
-                }
-
-                // Find the target status option
-                const targetOption = board.statusOptions.find(
-                    (opt) => opt.name.toLowerCase() === input.target_status.toLowerCase()
-                )
-
-                if (!targetOption) {
-                    return {
-                        error: `Status "${input.target_status}" not found in project`,
-                        availableStatuses: board.statusOptions.map((opt) => opt.name),
-                        hint: 'Use one of the available status names listed above.',
-                    }
-                }
-
-                // Move the item
-                const result = await github.moveProjectItem(
-                    board.projectId,
-                    input.item_id,
-                    board.statusFieldId,
-                    targetOption.id
-                )
-
-                if (!result.success) {
-                    return {
-                        success: false,
-                        error: result.error,
-                        targetStatus: input.target_status,
-                    }
-                }
-
-                return {
-                    success: true,
-                    itemId: input.item_id,
-                    newStatus: input.target_status,
-                    projectNumber: input.project_number,
-                    message: `Item moved to "${input.target_status}"`,
-                }
-            },
-        },
-        {
-            name: 'create_github_issue_with_entry',
-            title: 'Create GitHub Issue with Journal Entry',
-            description:
-                'Create a GitHub issue AND automatically create a linked journal entry documenting the issue creation.',
-            group: 'github',
-            inputSchema: z.object({
-                title: z.string().min(1).describe('Issue title'),
-                body: z.string().optional().describe('Issue body/description'),
-                labels: z.array(z.string()).optional().describe('Labels to apply'),
-                assignees: z.array(z.string()).optional().describe('Users to assign'),
-                milestone_number: z
-                    .number()
-                    .optional()
-                    .describe('Milestone number to assign this issue to'),
-                project_number: z
-                    .number()
-                    .optional()
-                    .describe('GitHub Project number to add this issue to'),
-                initial_status: z
-                    .string()
-                    .optional()
-                    .describe(
-                        'Initial status column (e.g., "Backlog", "Ready"). Defaults to "Backlog" when adding to a project.'
-                    ),
-                owner: z
-                    .string()
-                    .optional()
-                    .describe('Repository owner - LEAVE EMPTY to auto-detect'),
-                repo: z
-                    .string()
-                    .optional()
-                    .describe('Repository name - LEAVE EMPTY to auto-detect'),
-                entry_content: z
-                    .string()
-                    .optional()
-                    .describe('Custom journal content (defaults to auto-generated summary)'),
-                tags: z.array(z.string()).optional().describe('Journal entry tags'),
-            }),
-            outputSchema: CreateGitHubIssueWithEntryOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        title: z.string().min(1),
-                        body: z.string().optional(),
-                        labels: z.array(z.string()).optional(),
-                        assignees: z.array(z.string()).optional(),
-                        milestone_number: z.number().optional(),
-                        project_number: z.number().optional(),
-                        initial_status: z.string().optional(),
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                        entry_content: z.string().optional(),
-                        tags: z.array(z.string()).optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                // Get owner/repo from input or from current repo
-                const repoInfo = await github.getRepoInfo()
-                const owner = input.owner ?? repoInfo.owner ?? undefined
-                const repo = input.repo ?? repoInfo.repo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS.',
-                        requiresUserInput: true,
-                        detected: { owner, repo },
-                    }
-                }
-
-                // Create the GitHub issue
-                const issue = await github.createIssue(
-                    owner,
-                    repo,
-                    input.title,
-                    input.body,
-                    input.labels,
-                    input.assignees,
-                    input.milestone_number
-                )
-
-                if (!issue) {
-                    return {
-                        error: 'Failed to create GitHub issue. Check GITHUB_TOKEN permissions.',
-                    }
-                }
-
-                const projectNumber = input.project_number ?? context.config?.defaultProjectNumber
-
-                // Add to project if requested or default configured
-                let projectResult = undefined
-                if (projectNumber !== undefined && issue.nodeId) {
-                    try {
-                        // Get project ID (needed for mutation)
-                        const board = await github.getProjectKanban(owner, projectNumber, repo)
-                        if (board) {
-                            const added = await github.addProjectItem(board.projectId, issue.nodeId)
-                            if (added.success) {
-                                // Set initial status if provided
-                                let statusResult:
-                                    | { status: string; set: boolean; error?: string }
-                                    | undefined = undefined
-                                // Default to "Backlog" when adding to project without explicit status
-                                const initialStatus = input.initial_status ?? 'Backlog'
-                                if (initialStatus && added.itemId) {
-                                    // Find the status option (case-insensitive)
-                                    const statusOption = board.statusOptions.find(
-                                        (opt) =>
-                                            opt.name.toLowerCase() === initialStatus.toLowerCase()
-                                    )
-                                    if (statusOption) {
-                                        const moveResult = await github.moveProjectItem(
-                                            board.projectId,
-                                            added.itemId,
-                                            board.statusFieldId,
-                                            statusOption.id
-                                        )
-                                        if (moveResult.success) {
-                                            statusResult = { status: statusOption.name, set: true }
-                                        } else {
-                                            statusResult = {
-                                                status: initialStatus,
-                                                set: false,
-                                                error: moveResult.error,
-                                            }
-                                        }
-                                    } else {
-                                        statusResult = {
-                                            status: initialStatus,
-                                            set: false,
-                                            error: `Status "${initialStatus}" not found. Available: ${board.statusOptions.map((o) => o.name).join(', ')}`,
-                                        }
-                                    }
-                                }
-
-                                projectResult = {
-                                    projectNumber: projectNumber,
-                                    added: true,
-                                    message:
-                                        `Added to project #${projectNumber}` +
-                                        (statusResult?.set ? ` (${statusResult.status})` : ''),
-                                    initialStatus: statusResult,
-                                }
-                            } else {
-                                projectResult = {
-                                    projectNumber: projectNumber,
-                                    added: false,
-                                    error: added.error,
-                                }
-                            }
-                        } else {
-                            projectResult = {
-                                projectNumber: projectNumber,
-                                added: false,
-                                error: `Project #${projectNumber} not found`,
-                            }
-                        }
-                    } catch (error) {
-                        projectResult = {
-                            projectNumber: projectNumber,
-                            added: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }
-                    }
-                }
-
-                // Create linked journal entry
-                const entryContent =
-                    input.entry_content ??
-                    `Created GitHub issue #${String(issue.number)}: ${issue.title}\n\n` +
-                        `URL: ${issue.url}\n` +
-                        (projectNumber !== undefined ? `Project: #${projectNumber}\n` : '') +
-                        (input.body
-                            ? `\nDescription: ${input.body.slice(0, 200)}${input.body.length > 200 ? '...' : ''}`
-                            : '')
-
-                const entry = db.createEntry({
-                    content: entryContent,
-                    entryType: 'planning' as EntryType,
-                    tags: input.tags ?? ['github', 'issue-created'],
-                    isPersonal: false,
-                    significanceType: null,
-                    issueNumber: issue.number,
-                    issueUrl: issue.url,
-                    projectNumber: projectNumber,
-                })
-
-                return {
-                    success: true,
-                    issue: {
-                        number: issue.number,
-                        title: issue.title,
-                        url: issue.url,
-                    },
-                    project: projectResult,
-                    journalEntry: {
-                        id: entry.id,
-                        linkedToIssue: issue.number,
-                    },
-                    message:
-                        `Created issue #${String(issue.number)}` +
-                        (projectResult?.added ? ` (added to Project #${projectNumber})` : '') +
-                        ` and journal entry #${String(entry.id)}`,
-                }
-            },
-        },
-        {
-            name: 'close_github_issue_with_entry',
-            title: 'Close GitHub Issue with Resolution Entry',
-            description:
-                'Close a GitHub issue AND create a journal entry documenting the resolution.',
-            group: 'github',
-            inputSchema: z.object({
-                issue_number: z.number().describe('Issue number to close'),
-                resolution_notes: z
-                    .string()
-                    .optional()
-                    .describe('Notes about how the issue was resolved'),
-                comment: z
-                    .string()
-                    .optional()
-                    .describe('Comment to add to the issue before closing'),
-                move_to_done: z
-                    .boolean()
-                    .optional()
-                    .default(false)
-                    .describe('Move the associated Kanban item to "Done" column'),
-                project_number: z
-                    .number()
-                    .optional()
-                    .describe(
-                        'GitHub Project number (required if move_to_done is true, or uses DEFAULT_PROJECT_NUMBER)'
-                    ),
-                owner: z
-                    .string()
-                    .optional()
-                    .describe('Repository owner - LEAVE EMPTY to auto-detect'),
-                repo: z
-                    .string()
-                    .optional()
-                    .describe('Repository name - LEAVE EMPTY to auto-detect'),
-                tags: z.array(z.string()).optional().describe('Journal entry tags'),
-            }),
-            outputSchema: CloseGitHubIssueWithEntryOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        issue_number: z.number(),
-                        resolution_notes: z.string().optional(),
-                        comment: z.string().optional(),
-                        move_to_done: z.boolean().optional().default(false),
-                        project_number: z.number().optional(),
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                        tags: z.array(z.string()).optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                // Get owner/repo from input or from current repo
-                const repoInfo = await github.getRepoInfo()
-                const owner = input.owner ?? repoInfo.owner ?? undefined
-                const repo = input.repo ?? repoInfo.repo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS.',
-                        requiresUserInput: true,
-                        detected: { owner, repo },
-                    }
-                }
-
-                // Get issue details before closing
-                const issueDetails = await github.getIssue(owner, repo, input.issue_number)
-                if (!issueDetails) {
-                    return { error: `Issue #${String(input.issue_number)} not found` }
-                }
-
-                if (issueDetails.state === 'CLOSED') {
-                    return { error: `Issue #${String(input.issue_number)} is already closed` }
-                }
-
-                // Close the issue
-                const result = await github.closeIssue(
-                    owner,
-                    repo,
-                    input.issue_number,
-                    input.comment
-                )
-
-                if (!result) {
-                    return {
-                        error: 'Failed to close GitHub issue. Check GITHUB_TOKEN permissions.',
-                    }
-                }
-
-                // Move Kanban item to "Done" if requested
-                let kanbanResult:
-                    | { moved: boolean; error?: string; projectNumber?: number }
-                    | undefined
-                if (input.move_to_done) {
-                    const projectNum = input.project_number ?? context.config?.defaultProjectNumber
-                    if (projectNum === undefined) {
-                        kanbanResult = {
-                            moved: false,
-                            error: 'project_number required when move_to_done is true',
-                        }
-                    } else {
-                        try {
-                            const board = await github.getProjectKanban(owner, projectNum, repo)
-                            if (!board) {
-                                kanbanResult = {
-                                    moved: false,
-                                    error: `Project #${projectNum} not found`,
-                                    projectNumber: projectNum,
-                                }
-                            } else {
-                                // Find the item by issue number
-                                const item = board.columns
-                                    .flatMap((c) => c.items)
-                                    .find(
-                                        (i) => i.type === 'ISSUE' && i.number === input.issue_number
-                                    )
-                                if (!item) {
-                                    kanbanResult = {
-                                        moved: false,
-                                        error: 'Issue not found on project board',
-                                        projectNumber: projectNum,
-                                    }
-                                } else {
-                                    const doneOption = board.statusOptions.find(
-                                        (opt) => opt.name.toLowerCase() === 'done'
-                                    )
-                                    if (!doneOption) {
-                                        kanbanResult = {
-                                            moved: false,
-                                            error: '"Done" status column not found on board',
-                                            projectNumber: projectNum,
-                                        }
-                                    } else {
-                                        const moveResult = await github.moveProjectItem(
-                                            board.projectId,
-                                            item.id,
-                                            board.statusFieldId,
-                                            doneOption.id
-                                        )
-                                        kanbanResult = {
-                                            moved: moveResult.success,
-                                            error: moveResult.error,
-                                            projectNumber: projectNum,
-                                        }
-                                    }
-                                }
-                            }
-                        } catch (err) {
-                            kanbanResult = {
-                                moved: false,
-                                error: err instanceof Error ? err.message : String(err),
-                                projectNumber:
-                                    input.project_number ?? context.config?.defaultProjectNumber,
-                            }
-                        }
-                    }
-                }
-
-                // Create resolution journal entry
-                const entryContent =
-                    `Closed GitHub issue #${String(input.issue_number)}: ${issueDetails.title}\n\n` +
-                    `URL: ${issueDetails.url}\n` +
-                    (input.resolution_notes ? `\nResolution: ${input.resolution_notes}` : '')
-
-                const entry = db.createEntry({
-                    content: entryContent,
-                    entryType: 'bug_fix' as EntryType,
-                    tags: input.tags ?? ['github', 'issue-closed', 'resolution'],
-                    isPersonal: false,
-                    significanceType: 'blocker_resolved' as SignificanceType,
-                    issueNumber: input.issue_number,
-                    issueUrl: issueDetails.url,
-                })
-
-                return {
-                    success: true,
-                    issue: {
-                        number: input.issue_number,
-                        title: issueDetails.title,
-                        url: result.url,
-                        previousState: 'OPEN',
-                        newState: 'CLOSED',
-                    },
-                    journalEntry: {
-                        id: entry.id,
-                        linkedToIssue: input.issue_number,
-                        significanceType: 'blocker_resolved',
-                    },
-                    kanban: kanbanResult,
-                    message:
-                        `Closed issue #${String(input.issue_number)} and created resolution entry #${String(entry.id)}` +
-                        (kanbanResult?.moved ? ' and moved to Done' : ''),
-                }
-            },
-        },
-        // Milestone tools
-        {
-            name: 'get_github_milestones',
-            title: 'List GitHub Milestones',
-            description:
-                'List GitHub milestones for the repository with completion percentages and due dates.',
-            group: 'github',
-            inputSchema: z.object({
-                state: z
-                    .enum(['open', 'closed', 'all'])
-                    .optional()
-                    .default('open')
-                    .describe('Filter by state (default: open)'),
-                limit: z
-                    .number()
-                    .optional()
-                    .default(20)
-                    .describe('Max milestones to return (default: 20)'),
-                owner: z.string().optional().describe('LEAVE EMPTY to auto-detect from git'),
-                repo: z.string().optional().describe('LEAVE EMPTY to auto-detect from git'),
-            }),
-            outputSchema: GitHubMilestonesListOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        state: z.enum(['open', 'closed', 'all']).optional().default('open'),
-                        limit: z.number().optional().default(20),
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                const repoInfo = await github.getRepoInfo()
-                const detectedOwner = repoInfo.owner
-                const detectedRepo = repoInfo.repo
-
-                const owner = input.owner ?? detectedOwner ?? undefined
-                const repo = input.repo ?? detectedRepo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS. You MUST ask the user to provide the GitHub owner and repository name.',
-                        requiresUserInput: true,
-                        detectedOwner,
-                        detectedRepo,
-                        instruction:
-                            'Ask the user: "What GitHub repository should I list milestones for? Please provide the owner and repo name (e.g., owner/repo)."',
-                    }
-                }
-
-                const milestones = await github.getMilestones(owner, repo, input.state, input.limit)
-                const milestonesWithPercentage = milestones.map((ms) => {
-                    const total = ms.openIssues + ms.closedIssues
-                    const completionPercentage =
-                        total > 0 ? Math.round((ms.closedIssues / total) * 100) : 0
-                    return { ...ms, completionPercentage }
-                })
-
-                return {
-                    milestones: milestonesWithPercentage,
-                    count: milestonesWithPercentage.length,
-                    owner,
-                    repo,
-                    detectedOwner,
-                    detectedRepo,
-                }
-            },
-        },
-        {
-            name: 'get_github_milestone',
-            title: 'Get GitHub Milestone Details',
-            description:
-                'Get detailed information about a specific GitHub milestone including progress and linked issue counts.',
-            group: 'github',
-            inputSchema: z.object({
-                milestone_number: z.number().describe('Milestone number'),
-                owner: z.string().optional().describe('LEAVE EMPTY to auto-detect from git'),
-                repo: z.string().optional().describe('LEAVE EMPTY to auto-detect from git'),
-            }),
-            outputSchema: GitHubMilestoneResultOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        milestone_number: z.number(),
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                const repoInfo = await github.getRepoInfo()
-                const detectedOwner = repoInfo.owner
-                const detectedRepo = repoInfo.repo
-
-                const owner = input.owner ?? detectedOwner ?? undefined
-                const repo = input.repo ?? detectedRepo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS. You MUST ask the user to provide the GitHub owner and repository name.',
-                        requiresUserInput: true,
-                        detectedOwner,
-                        detectedRepo,
-                        instruction:
-                            'Ask the user: "What GitHub repository is this milestone from? Please provide the owner and repo name (e.g., owner/repo)."',
-                    }
-                }
-
-                const milestone = await github.getMilestone(owner, repo, input.milestone_number)
-                if (!milestone) {
-                    return {
-                        error: `Milestone #${String(input.milestone_number)} not found`,
-                        owner,
-                        repo,
-                        detectedOwner,
-                        detectedRepo,
-                    }
-                }
-
-                const total = milestone.openIssues + milestone.closedIssues
-                const completionPercentage =
-                    total > 0 ? Math.round((milestone.closedIssues / total) * 100) : 0
-
-                return {
-                    milestone: { ...milestone, completionPercentage },
-                    owner,
-                    repo,
-                    detectedOwner,
-                    detectedRepo,
-                }
-            },
-        },
-        {
-            name: 'create_github_milestone',
-            title: 'Create GitHub Milestone',
-            description:
-                'Create a new GitHub milestone for tracking progress toward a project goal.',
-            group: 'github',
-            inputSchema: z.object({
-                title: z.string().min(1).describe('Milestone title'),
-                description: z.string().optional().describe('Milestone description'),
-                due_on: z.string().optional().describe('Due date in YYYY-MM-DD format (optional)'),
-                owner: z.string().optional().describe('LEAVE EMPTY to auto-detect'),
-                repo: z.string().optional().describe('LEAVE EMPTY to auto-detect'),
-            }),
-            outputSchema: CreateMilestoneOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        title: z.string().min(1),
-                        description: z.string().optional(),
-                        due_on: z.string().optional(),
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                const repoInfo = await github.getRepoInfo()
-                const owner = input.owner ?? repoInfo.owner ?? undefined
-                const repo = input.repo ?? repoInfo.repo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS.',
-                        requiresUserInput: true,
-                        instruction:
-                            'Ask the user: "What GitHub repository should I create the milestone in?"',
-                    }
-                }
-
-                // Format due_on to ISO 8601 if provided (GitHub expects YYYY-MM-DDTHH:MM:SSZ)
-                const dueOn = input.due_on ? `${input.due_on}T08:00:00Z` : undefined
-
-                const milestone = await github.createMilestone(
-                    owner,
-                    repo,
-                    input.title,
-                    input.description,
-                    dueOn
-                )
-
-                if (!milestone) {
-                    return {
-                        error: 'Failed to create milestone. Check GITHUB_TOKEN permissions.',
-                    }
-                }
-
-                return {
-                    success: true,
-                    milestone: { ...milestone, completionPercentage: 0 },
-                    message: `Created milestone #${String(milestone.number)}: ${milestone.title}`,
-                }
-            },
-        },
-        {
-            name: 'update_github_milestone',
-            title: 'Update GitHub Milestone',
-            description:
-                'Update a GitHub milestone (title, description, due date, or state). Use state "closed" to close a completed milestone.',
-            group: 'github',
-            inputSchema: z.object({
-                milestone_number: z.number().describe('Milestone number to update'),
-                title: z.string().optional().describe('New title'),
-                description: z.string().optional().describe('New description'),
-                due_on: z.string().optional().describe('New due date in YYYY-MM-DD format'),
-                state: z
-                    .enum(['open', 'closed'])
-                    .optional()
-                    .describe('Set to "closed" to close the milestone'),
-                owner: z.string().optional().describe('LEAVE EMPTY to auto-detect'),
-                repo: z.string().optional().describe('LEAVE EMPTY to auto-detect'),
-            }),
-            outputSchema: UpdateMilestoneOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        milestone_number: z.number(),
-                        title: z.string().optional(),
-                        description: z.string().optional(),
-                        due_on: z.string().optional(),
-                        state: z.enum(['open', 'closed']).optional(),
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                const repoInfo = await github.getRepoInfo()
-                const owner = input.owner ?? repoInfo.owner ?? undefined
-                const repo = input.repo ?? repoInfo.repo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS.',
-                        requiresUserInput: true,
-                        instruction: 'Ask the user: "What GitHub repository is this milestone in?"',
-                    }
-                }
-
-                const dueOn = input.due_on ? `${input.due_on}T08:00:00Z` : undefined
-
-                const milestone = await github.updateMilestone(
-                    owner,
-                    repo,
-                    input.milestone_number,
-                    {
-                        title: input.title,
-                        description: input.description,
-                        dueOn,
-                        state: input.state,
-                    }
-                )
-
-                if (!milestone) {
-                    return {
-                        error: `Failed to update milestone #${String(input.milestone_number)}. Check that it exists and GITHUB_TOKEN has permissions.`,
-                    }
-                }
-
-                const total = milestone.openIssues + milestone.closedIssues
-                const completionPercentage =
-                    total > 0 ? Math.round((milestone.closedIssues / total) * 100) : 0
-
-                return {
-                    success: true,
-                    milestone: { ...milestone, completionPercentage },
-                    message: `Updated milestone #${String(milestone.number)}: ${milestone.title}`,
-                }
-            },
-        },
-        {
-            name: 'delete_github_milestone',
-            title: 'Delete GitHub Milestone',
-            description:
-                'Permanently delete a GitHub milestone. Issues assigned to the milestone will be un-assigned but not deleted.',
-            group: 'github',
-            inputSchema: z.object({
-                milestone_number: z.number().describe('Milestone number to delete'),
-                confirm: z.literal(true).describe('Must be set to true to confirm deletion'),
-                owner: z.string().optional().describe('LEAVE EMPTY to auto-detect'),
-                repo: z.string().optional().describe('LEAVE EMPTY to auto-detect'),
-            }),
-            outputSchema: DeleteMilestoneOutputSchema,
-            annotations: {
-                readOnlyHint: false,
-                idempotentHint: false,
-                destructiveHint: true,
-                openWorldHint: true,
-            },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        milestone_number: z.number(),
-                        confirm: z.literal(true),
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                const repoInfo = await github.getRepoInfo()
-                const owner = input.owner ?? repoInfo.owner ?? undefined
-                const repo = input.repo ?? repoInfo.repo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS.',
-                        requiresUserInput: true,
-                        instruction: 'Ask the user: "What GitHub repository is this milestone in?"',
-                    }
-                }
-
-                const result = await github.deleteMilestone(owner, repo, input.milestone_number)
-
-                if (!result.success) {
-                    return {
-                        success: false,
-                        milestoneNumber: input.milestone_number,
-                        message: `Failed to delete milestone #${String(input.milestone_number)}`,
-                        error: result.error ?? undefined,
-                    }
-                }
-
-                return {
-                    success: true,
-                    milestoneNumber: input.milestone_number,
-                    message: `Deleted milestone #${String(input.milestone_number)}`,
-                }
-            },
-        },
-        // Repository insights tool
-        {
-            name: 'get_repo_insights',
-            title: 'Repository Insights',
-            description:
-                'Get repository insights: stars, forks, traffic (clones/views), referrers, and popular paths. Use "sections" to control token usage: stars (~50 tokens), traffic (~100), referrers (~100), paths (~100), or all (~350).',
-            group: 'github',
-            inputSchema: z.object({
-                sections: z
-                    .enum(['stars', 'traffic', 'referrers', 'paths', 'all'])
-                    .optional()
-                    .default('stars')
-                    .describe(
-                        'Data section to return (default: stars). Use "all" for full payload.'
-                    ),
-                owner: z
-                    .string()
-                    .optional()
-                    .describe('Repository owner - LEAVE EMPTY to auto-detect'),
-                repo: z
-                    .string()
-                    .optional()
-                    .describe('Repository name - LEAVE EMPTY to auto-detect'),
-            }),
-            outputSchema: RepoInsightsOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        sections: z
-                            .enum(['stars', 'traffic', 'referrers', 'paths', 'all'])
-                            .optional()
-                            .default('stars'),
-                        owner: z.string().optional(),
-                        repo: z.string().optional(),
-                    })
-                    .parse(params)
-
-                if (!github) {
-                    return { error: 'GitHub integration not available' }
-                }
-
-                const repoInfo = await github.getRepoInfo()
-                const owner = input.owner ?? repoInfo.owner ?? undefined
-                const repo = input.repo ?? repoInfo.repo ?? undefined
-
-                if (!owner || !repo) {
-                    return {
-                        error: 'STOP: Could not auto-detect repository. DO NOT GUESS. You MUST ask the user to provide the GitHub owner and repository name.',
-                        requiresUserInput: true,
-                        instruction:
-                            'Ask the user: "What GitHub repository should I get insights for? Please provide the owner and repo name (e.g., owner/repo)."',
-                    }
-                }
-
-                const section = input.sections
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- building response dynamically
-                const result: Record<string, any> = {
-                    owner,
-                    repo,
-                    section,
-                }
-
-                // Stars section (default)
-                if (section === 'stars' || section === 'all') {
-                    const stats = await github.getRepoStats(owner, repo)
-                    if (stats) {
-                        result['stars'] = stats.stars
-                        result['forks'] = stats.forks
-                        result['watchers'] = stats.watchers
-                        result['openIssues'] = stats.openIssues
-                        if (section === 'all') {
-                            result['size'] = stats.size
-                            result['defaultBranch'] = stats.defaultBranch
-                        }
-                    }
-                }
-
-                // Traffic section
-                if (section === 'traffic' || section === 'all') {
-                    const traffic = await github.getTrafficData(owner, repo)
-                    if (traffic) {
-                        result['traffic'] = traffic
-                    }
-                }
-
-                // Referrers section
-                if (section === 'referrers' || section === 'all') {
-                    const referrers = await github.getTopReferrers(owner, repo, 5)
-                    result['referrers'] = referrers
-                }
-
-                // Paths section
-                if (section === 'paths' || section === 'all') {
-                    const paths = await github.getPopularPaths(owner, repo, 5)
-                    result['paths'] = paths
-                }
-
-                return result
-            },
-        },
-        // Backup tools
-        {
-            name: 'backup_journal',
-            title: 'Backup Journal Database',
-            description:
-                'Create a timestamped backup of the journal database. Backups are stored in the backups/ directory.',
-            group: 'backup',
-            inputSchema: z.object({
-                name: z
-                    .string()
-                    .optional()
-                    .describe('Custom backup name (optional, defaults to timestamp)'),
-            }),
-            outputSchema: BackupResultOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: true },
-            handler: (params: unknown) => {
-                const input = z
-                    .object({
-                        name: z.string().optional(),
-                    })
-                    .parse(params)
-                const result = db.exportToFile(input.name)
-                return Promise.resolve({
-                    success: true,
-                    message: `Backup created successfully`,
-                    filename: result.filename,
-                    path: result.path,
-                    sizeBytes: result.sizeBytes,
-                })
-            },
-        },
-        {
-            name: 'list_backups',
-            title: 'List Journal Backups',
-            description: 'List all available backup files with their sizes and creation dates',
-            group: 'backup',
-            inputSchema: z.object({}),
-            outputSchema: BackupsListOutputSchema,
-            annotations: { readOnlyHint: true, idempotentHint: true },
-            handler: (_params: unknown) => {
-                const backups = db.listBackups()
-                return Promise.resolve({
-                    backups,
-                    total: backups.length,
-                    backupsDirectory: db.getBackupsDir(),
-                    hint:
-                        backups.length === 0
-                            ? 'No backups found. Use backup_journal to create one.'
-                            : undefined,
-                })
-            },
-        },
-        {
-            name: 'restore_backup',
-            title: 'Restore Journal from Backup',
-            description:
-                'Restore the journal database from a backup file. WARNING: This replaces all current data. An automatic backup is created before restore.',
-            group: 'backup',
-            inputSchema: z.object({
-                filename: z
-                    .string()
-                    .describe('Backup filename to restore from (e.g., backup_2025-01-01.db)'),
-                confirm: z
-                    .literal(true)
-                    .describe('Must be set to true to confirm the restore operation'),
-            }),
-            outputSchema: RestoreResultOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false, destructiveHint: true },
-            handler: async (params: unknown) => {
-                const input = z
-                    .object({
-                        filename: z.string(),
-                        confirm: z.literal(true),
-                    })
-                    .parse(params)
-
-                // Capture progress context values BEFORE any async operations
-                // This prevents any possible reference corruption during db reinitialization
-                const progressServer = progress?.server
-                const progressTokenValue = progress?.progressToken
-
-                // Phase 1: Notify that we're starting
-                await sendProgress(progress, 1, 3, 'Preparing restore...')
-
-                // Phase 2: Restoring database (restoreFromFile creates backup internally)
-                await sendProgress(progress, 2, 3, 'Restoring database from backup...')
-                const result = await db.restoreFromFile(input.filename)
-
-                // Phase 3: Complete - send directly using captured primitives
-                // The db.restoreFromFile() reinitializes the database which can corrupt
-                // the progress context, so we use our captured values
-                if (progressServer !== undefined && progressTokenValue !== undefined) {
-                    try {
-                        await progressServer.notification({
-                            method: 'notifications/progress' as const,
-                            params: {
-                                progressToken: progressTokenValue,
-                                progress: 3,
-                                total: 3,
-                                message: 'Restore complete',
-                            },
-                        })
-                    } catch {
-                        // Best-effort notification
-                    }
-                }
-
-                return {
-                    success: true,
-                    message: `Database restored from ${input.filename}`,
-                    restoredFrom: result.restoredFrom,
-                    previousEntryCount: result.previousEntryCount,
-                    newEntryCount: result.newEntryCount,
-                    warning:
-                        'A pre-restore backup was automatically created. Any changes made since this backup (including tag merges, new entries, and relationships) have been reverted.',
-                    revertedChanges: {
-                        tagMerges:
-                            'Any merge_tags operations since this backup are reverted. Previously merged tags will reappear as separate tags.',
-                        entries:
-                            result.previousEntryCount !== result.newEntryCount
-                                ? `Entry count changed from ${String(result.previousEntryCount)} to ${String(result.newEntryCount)}`
-                                : undefined,
-                    },
-                }
-            },
-        },
-        {
-            name: 'cleanup_backups',
-            title: 'Cleanup Old Backups',
-            description:
-                'Delete old backup files, keeping only the most recent N backups. Use list_backups to preview before cleanup.',
-            group: 'backup',
-            inputSchema: z.object({
-                keep_count: z
-                    .number()
-                    .min(1)
-                    .default(5)
-                    .describe('Number of most recent backups to keep (default: 5)'),
-            }),
-            outputSchema: CleanupBackupsOutputSchema,
-            annotations: { readOnlyHint: false, idempotentHint: false },
-            handler: (params: unknown) => {
-                const { keep_count } = z
-                    .object({ keep_count: z.number().min(1).default(5) })
-                    .parse(params)
-
-                const result = db.deleteOldBackups(keep_count)
-
-                return Promise.resolve({
-                    success: true,
-                    deleted: result.deleted,
-                    deletedCount: result.deleted.length,
-                    keptCount: result.kept,
-                    message:
-                        result.deleted.length > 0
-                            ? `Deleted ${String(result.deleted.length)} old backup(s), kept ${String(result.kept)}`
-                            : `No backups to delete. Currently have ${String(result.kept)} backup(s).`,
-                })
-            },
-        },
+        ...getCoreTools(context),
+        ...getSearchTools(context),
+        ...getAnalyticsTools(context),
+        ...getRelationshipTools(context),
+        ...getExportTools(context),
+        ...getAdminTools(context),
+        ...getGitHubTools(context),
+        ...getBackupTools(context),
+        ...getTeamTools(context),
     ]
 }