memory-journal-mcp 4.4.2 → 5.0.0

package/dist/handlers/tools/index.js

@@ -1,2934 +1,142 @@
 /**
- * Memory Journal MCP Server - Tool Handlers
+ * Tool Handler Barrel
  *
- * Exports all MCP tools with annotations following MCP 2025-11-25 spec.
- */
-import { z } from 'zod';
-import { sendProgress } from '../../utils/progress-utils.js';
-import { getToolIcon } from '../../constants/icons.js';
-// ============================================================================
-// 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)
-// ============================================================================
-/**
- * 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(),
-});
+ * 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 { 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';
+// ============================================================================
+// Icon Mapping
+// ============================================================================
+function getToolIcon(group) {
+    const iconMap = {
+        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];
+}
 // ============================================================================
-// Tool Definitions with MCP 2025-11-25 Annotations
+// Public API
 // ============================================================================
 /**
- * Get all tool definitions
+ * Get all tool definitions, optionally filtered by config
  */
-export function getTools(db, filterConfig, vectorManager, github, config) {
-    const context = { db, vectorManager, github, config };
+export function getTools(db, filterConfig, vectorManager, github, config, teamDb) {
+    const context = { 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) => ({
         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 = null;
+let cachedContextRefs = null;
 /**
  * Call a tool by name
  */
-export async function callTool(name, args, db, vectorManager, github, config, progress) {
-    const context = { db, vectorManager, github, config, progress };
-    const tools = getAllToolDefinitions(context);
-    const tool = tools.find((t) => t.name === name);
+export function callTool(name, args, db, vectorManager, github, config, progress, teamDb) {
+    const context = { 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) {
-    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) => {
-                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,
-                    tags: input.tags,
-                    isPersonal: input.is_personal,
-                    significanceType: input.significance_type ?? 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) => {
-                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 = {
-                    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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                const input = SearchByDateRangeSchema.parse(params);
-                const entries = db.searchByDateRange(input.start_date, input.end_date, {
-                    entryType: input.entry_type,
-                    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) => {
-                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 !== 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) => {
-                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) => {
-                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 = [];
-                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 = {};
-                    columns.forEach((col, i) => {
-                        obj[col] = row[i];
-                    });
-                    return obj;
-                });
-                // Get top tags per project
-                const projectTags = {};
-                for (const proj of projects) {
-                    const projNum = proj['project_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],
-                            count: row[1],
-                        }));
-                    }
-                }
-                // 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],
-                    last_entry_date: row[1],
-                })) ?? [];
-                // Calculate time distribution
-                const totalEntries = projects.reduce((sum, p) => sum + p['entry_count'], 0);
-                const distribution = projects.slice(0, 5).map((p) => ({
-                    project_number: p['project_number'],
-                    percentage: ((p['entry_count'] / 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']] ?? [],
-                    })),
-                    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) => {
-                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, 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) => {
-                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 = {};
-                const cols = entriesResult[0].columns;
-                for (const row of entriesResult[0].values) {
-                    const id = row[cols.indexOf('id')];
-                    entries[id] = {
-                        id,
-                        entry_type: row[cols.indexOf('entry_type')],
-                        content: row[cols.indexOf('content')],
-                        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 = {
-                    references: '-->',
-                    implements: '==>',
-                    clarifies: '-.->',
-                    evolves_from: '-->',
-                    response_to: '<-->',
-                    // Causal relationship types
-                    blocked_by: '--x',
-                    resolved: '==>',
-                    caused: '-.->',
-                };
-                for (const rel of relationships) {
-                    const fromId = rel[0];
-                    const toId = rel[1];
-                    const relType = rel[2];
-                    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) => {
-                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) => {
-                const input = UpdateEntrySchema.parse(params);
-                const entry = db.updateEntry(input.entry_id, {
-                    content: input.content,
-                    entryType: input.entry_type,
-                    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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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 = 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',
-                    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) => {
-                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;
-                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',
-                    tags: input.tags ?? ['github', 'issue-closed', 'resolution'],
-                    isPersonal: false,
-                    significanceType: 'blocker_resolved',
-                    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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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) => {
-                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 = {
-                    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) => {
-                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) => {
-                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) => {
-                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',
-                            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) => {
-                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),
     ];
 }
 //# sourceMappingURL=index.js.map