@aaronsb/kg-cli 0.6.6 → 0.8.0

package/dist/mcp-server.js

@@ -49,7 +49,8 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const client_js_1 = require("./api/client.js");
 const auth_client_js_1 = require("./lib/auth/auth-client.js");
 const mcp_allowlist_js_1 = require("./lib/mcp-allowlist.js");
-const formatters_js_1 = require("./mcp/formatters.js");
+const index_js_2 = require("./mcp/formatters/index.js");
+const graph_operations_js_1 = require("./mcp/graph-operations.js");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const package_json_1 = __importDefault(require("../package.json"));
@@ -389,46 +390,135 @@ PERFORMANCE CRITICAL: For "connect" action, use threshold >= 0.75 to avoid datab
                     properties: {
                         action: {
                             type: 'string',
-                            enum: ['list', 'info', 'files', 'delete'],
-                            description: 'Operation: "list" (all ontologies), "info" (details), "files" (source files), "delete" (remove)',
+                            enum: ['list', 'info', 'files', 'create', 'rename', 'delete', 'lifecycle', 'scores', 'score', 'score_all', 'candidates', 'affinity', 'edges', 'reassign', 'dissolve', 'proposals', 'proposal_review', 'annealing_cycle'],
+                            description: 'Operation: "list" (all ontologies), "info" (details), "files" (source files), "create" (new ontology), "rename" (change name), "delete" (remove), "lifecycle" (set state), "scores" (cached scores), "score" (recompute one), "score_all" (recompute all), "candidates" (top concepts), "affinity" (cross-ontology overlap), "edges" (ontology-to-ontology edges), "reassign" (move sources), "dissolve" (non-destructive demotion), "proposals" (list annealing proposals), "proposal_review" (approve/reject proposal), "annealing_cycle" (trigger annealing cycle)',
                         },
                         ontology_name: {
                             type: 'string',
-                            description: 'Ontology name (required for info, files, delete)',
+                            description: 'Ontology name (required for info, files, create, rename, delete)',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'What this knowledge domain covers (for create action)',
+                        },
+                        new_name: {
+                            type: 'string',
+                            description: 'New ontology name (required for rename action)',
+                        },
+                        lifecycle_state: {
+                            type: 'string',
+                            enum: ['active', 'pinned', 'frozen'],
+                            description: 'Target lifecycle state (required for lifecycle action)',
                         },
                         force: {
                             type: 'boolean',
                             description: 'Confirm deletion (required for delete)',
                             default: false,
                         },
+                        target_ontology: {
+                            type: 'string',
+                            description: 'Target ontology for reassign/dissolve actions',
+                        },
+                        source_ids: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Source IDs to move (for reassign action)',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Max results for candidates/affinity (default: 20/10)',
+                        },
+                        proposal_id: {
+                            type: 'number',
+                            description: 'Proposal ID (for proposal_review action)',
+                        },
+                        status: {
+                            type: 'string',
+                            enum: ['pending', 'approved', 'rejected', 'executing', 'executed', 'failed'],
+                            description: 'Filter proposals by status, or review status (approved/rejected)',
+                        },
+                        proposal_type: {
+                            type: 'string',
+                            enum: ['promotion', 'demotion'],
+                            description: 'Filter proposals by type',
+                        },
+                        notes: {
+                            type: 'string',
+                            description: 'Review notes (for proposal_review action)',
+                        },
+                        dry_run: {
+                            type: 'boolean',
+                            description: 'Preview candidates without proposals (for annealing_cycle)',
+                            default: false,
+                        },
+                        demotion_threshold: {
+                            type: 'number',
+                            description: 'Protection score below which to consider demotion (default: 0.15)',
+                        },
+                        promotion_min_degree: {
+                            type: 'number',
+                            description: 'Minimum concept degree for promotion candidacy (default: 10)',
+                        },
+                        max_proposals: {
+                            type: 'number',
+                            description: 'Maximum proposals per annealing cycle (default: 5)',
+                        },
                     },
                     required: ['action'],
                 },
             },
             {
                 name: 'job',
-                description: 'Manage ingestion jobs: get status, list jobs, approve, or cancel. Use action parameter to specify operation.',
+                description: 'Manage ingestion jobs: get status, list jobs, approve, cancel, delete, or cleanup. Use action parameter to specify operation.',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         action: {
                             type: 'string',
-                            enum: ['status', 'list', 'approve', 'cancel'],
-                            description: 'Operation: "status" (get job status), "list" (list jobs), "approve" (approve job), "cancel" (cancel job)',
+                            enum: ['status', 'list', 'approve', 'cancel', 'delete', 'cleanup'],
+                            description: 'Operation: "status" (get job status), "list" (list jobs), "approve" (approve job), "cancel" (cancel job), "delete" (permanently delete single job), "cleanup" (delete jobs matching filters)',
                         },
                         job_id: {
                             type: 'string',
-                            description: 'Job ID (required for status, approve, cancel)',
+                            description: 'Job ID (required for status, approve, cancel, delete)',
                         },
                         status: {
                             type: 'string',
-                            description: 'Filter by status for list (pending, awaiting_approval, running, completed, failed)',
+                            description: 'Filter by status for list/cleanup (pending, awaiting_approval, running, completed, failed)',
                         },
                         limit: {
                             type: 'number',
                             description: 'Max jobs to return for list (default: 50)',
                             default: 50,
                         },
+                        force: {
+                            type: 'boolean',
+                            description: 'Force delete even if job is processing (for delete action)',
+                            default: false,
+                        },
+                        system_only: {
+                            type: 'boolean',
+                            description: 'Only delete system/scheduled jobs (for cleanup action)',
+                            default: false,
+                        },
+                        older_than: {
+                            type: 'string',
+                            description: 'Delete jobs older than duration: 1h, 24h, 7d, 30d (for cleanup action)',
+                        },
+                        job_type: {
+                            type: 'string',
+                            description: 'Filter by job type for cleanup (ingestion, epistemic_remeasurement, projection, etc)',
+                        },
+                        dry_run: {
+                            type: 'boolean',
+                            description: 'Preview what would be deleted without deleting (for cleanup, default: true)',
+                            default: true,
+                        },
+                        confirm: {
+                            type: 'boolean',
+                            description: 'Confirm deletion - set to true to actually delete (for cleanup action)',
+                            default: false,
+                        },
                     },
                     required: ['action'],
                 },
@@ -749,6 +839,193 @@ Use search tool with type="documents" to find documents semantically.`,
                     required: ['action'],
                 },
             },
+            // ADR-089 Phase 3a: Graph CRUD Tool
+            {
+                name: 'graph',
+                description: `Create, edit, delete, and list concepts and edges in the knowledge graph (ADR-089).
+
+This tool provides deterministic graph editing without going through the LLM ingest pipeline.
+Use for manual curation, agent-driven knowledge building, and precise graph manipulation.
+
+**Actions:**
+- "create": Create a new concept or edge
+- "edit": Update an existing concept or edge
+- "delete": Delete a concept or edge
+- "list": List concepts or edges with filters
+
+**Entity Types:**
+- "concept": Knowledge graph concepts (nodes)
+- "edge": Relationships between concepts
+
+**Matching Modes (for create):**
+- "auto": Link to existing if match found, create if not (default)
+- "force_create": Always create new, even if similar exists
+- "match_only": Only link to existing, error if no match
+
+**Semantic Resolution:**
+- Use \`from_label\`/\`to_label\` to reference concepts by name instead of ID
+- Resolution uses vector similarity (85% threshold) to find matching concepts
+
+**Examples:**
+- Create concept: \`{action: "create", entity: "concept", label: "CAP Theorem", ontology: "distributed-systems"}\`
+- Create edge: \`{action: "create", entity: "edge", from_label: "CAP Theorem", to_label: "Partition Tolerance", relationship_type: "REQUIRES"}\`
+- List concepts: \`{action: "list", entity: "concept", ontology: "distributed-systems"}\`
+- Delete concept: \`{action: "delete", entity: "concept", concept_id: "c_abc123"}\`
+
+**Queue Mode** (batch multiple operations in one call):
+\`\`\`json
+{
+  "action": "queue",
+  "operations": [
+    {"op": "create", "entity": "concept", "label": "A", "ontology": "test"},
+    {"op": "create", "entity": "concept", "label": "B", "ontology": "test"},
+    {"op": "create", "entity": "edge", "from_label": "A", "to_label": "B", "relationship_type": "IMPLIES"}
+  ]
+}
+\`\`\`
+Queue executes sequentially, stops on first error (unless continue_on_error=true). Max 20 operations.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            enum: ['create', 'edit', 'delete', 'list', 'queue'],
+                            description: 'Operation to perform. Use "queue" to batch multiple operations.',
+                        },
+                        entity: {
+                            type: 'string',
+                            enum: ['concept', 'edge'],
+                            description: 'Entity type (required for create/edit/delete/list, not for queue)',
+                        },
+                        // Queue fields
+                        operations: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    op: { type: 'string', enum: ['create', 'edit', 'delete', 'list'], description: 'Operation' },
+                                    entity: { type: 'string', enum: ['concept', 'edge'] },
+                                    label: { type: 'string' },
+                                    ontology: { type: 'string' },
+                                    description: { type: 'string' },
+                                    search_terms: { type: 'array', items: { type: 'string' } },
+                                    matching_mode: { type: 'string', enum: ['auto', 'force_create', 'match_only'] },
+                                    concept_id: { type: 'string' },
+                                    from_concept_id: { type: 'string' },
+                                    to_concept_id: { type: 'string' },
+                                    from_label: { type: 'string' },
+                                    to_label: { type: 'string' },
+                                    relationship_type: { type: 'string' },
+                                    category: { type: 'string' },
+                                    confidence: { type: 'number' },
+                                    limit: { type: 'number' },
+                                    offset: { type: 'number' },
+                                    cascade: { type: 'boolean' },
+                                },
+                                required: ['op', 'entity'],
+                            },
+                            description: 'Array of operations for queue action (max 20). Each has op, entity, and action-specific fields.',
+                        },
+                        continue_on_error: {
+                            type: 'boolean',
+                            description: 'For queue: continue executing after errors (default: false, stop on first error)',
+                            default: false,
+                        },
+                        // Concept fields
+                        label: {
+                            type: 'string',
+                            description: 'Concept label (required for create concept)',
+                        },
+                        ontology: {
+                            type: 'string',
+                            description: 'Ontology/namespace (required for create concept, optional filter for list)',
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Concept description (optional)',
+                        },
+                        search_terms: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Alternative search terms for the concept',
+                        },
+                        matching_mode: {
+                            type: 'string',
+                            enum: ['auto', 'force_create', 'match_only'],
+                            description: 'How to handle similar existing concepts (default: auto)',
+                            default: 'auto',
+                        },
+                        // Edge fields
+                        from_concept_id: {
+                            type: 'string',
+                            description: 'Source concept ID (for edge create/delete)',
+                        },
+                        to_concept_id: {
+                            type: 'string',
+                            description: 'Target concept ID (for edge create/delete)',
+                        },
+                        from_label: {
+                            type: 'string',
+                            description: 'Source concept by label (semantic resolution)',
+                        },
+                        to_label: {
+                            type: 'string',
+                            description: 'Target concept by label (semantic resolution)',
+                        },
+                        relationship_type: {
+                            type: 'string',
+                            description: 'Edge relationship type (e.g., IMPLIES, SUPPORTS, CONTRADICTS)',
+                        },
+                        category: {
+                            type: 'string',
+                            enum: ['logical_truth', 'causal', 'structural', 'temporal', 'comparative', 'functional', 'definitional'],
+                            description: 'Semantic category of the relationship (default: structural)',
+                            default: 'structural',
+                        },
+                        confidence: {
+                            type: 'number',
+                            description: 'Edge confidence 0.0-1.0 (default: 1.0)',
+                            default: 1.0,
+                        },
+                        // Identifiers for edit/delete
+                        concept_id: {
+                            type: 'string',
+                            description: 'Concept ID (for edit/delete concept)',
+                        },
+                        // List filters
+                        label_contains: {
+                            type: 'string',
+                            description: 'Filter concepts by label substring (for list)',
+                        },
+                        creation_method: {
+                            type: 'string',
+                            description: 'Filter by creation method (for list)',
+                        },
+                        source: {
+                            type: 'string',
+                            description: 'Filter edges by source (for list)',
+                        },
+                        // Pagination
+                        limit: {
+                            type: 'number',
+                            description: 'Max results to return (default: 20)',
+                            default: 20,
+                        },
+                        offset: {
+                            type: 'number',
+                            description: 'Number to skip for pagination (default: 0)',
+                            default: 0,
+                        },
+                        // Delete option
+                        cascade: {
+                            type: 'boolean',
+                            description: 'For concept delete: also delete orphaned synthetic sources (default: false)',
+                            default: false,
+                        },
+                    },
+                    required: ['action'],
+                },
+            },
         ],
     };
 });
@@ -806,7 +1083,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatDatabaseStats)(result)
+                            text: (0, index_js_2.formatDatabaseStats)(result)
                         }]
                 };
             }
@@ -816,7 +1093,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatDatabaseInfo)(result)
+                            text: (0, index_js_2.formatDatabaseInfo)(result)
                         }]
                 };
             }
@@ -826,7 +1103,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatDatabaseHealth)(result)
+                            text: (0, index_js_2.formatDatabaseHealth)(result)
                         }]
                 };
             }
@@ -836,7 +1113,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatSystemStatus)(result)
+                            text: (0, index_js_2.formatSystemStatus)(result)
                         }]
                 };
             }
@@ -846,7 +1123,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatApiHealth)(result)
+                            text: (0, index_js_2.formatApiHealth)(result)
                         }]
                 };
             }
@@ -858,7 +1135,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                         contents: [{
                                 uri,
                                 mimeType: 'text/plain',
-                                text: (0, formatters_js_1.formatMcpAllowedPaths)({
+                                text: (0, index_js_2.formatMcpAllowedPaths)({
                                     configured: false,
                                     message: 'Allowlist not initialized. Run: kg mcp-config init-allowlist',
                                     hint: 'Initialize with default safe patterns for .md, .txt, .pdf, .png, .jpg files'
@@ -870,7 +1147,7 @@ server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) =
                     contents: [{
                             uri,
                             mimeType: 'text/plain',
-                            text: (0, formatters_js_1.formatMcpAllowedPaths)({
+                            text: (0, index_js_2.formatMcpAllowedPaths)({
                                 configured: true,
                                 version: config.version,
                                 allowed_directories: config.allowed_directories,
@@ -948,7 +1225,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         include_concepts: true,
                         include_full_text: true,
                     });
-                    const formattedText = (0, formatters_js_1.formatSourceSearchResults)(result);
+                    const formattedText = (0, index_js_2.formatSourceSearchResults)(result);
                     return {
                         content: [{ type: 'text', text: formattedText }],
                     };
@@ -963,7 +1240,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     });
                     // Add query to result for formatting
                     const resultWithQuery = { ...result, query };
-                    const formattedText = (0, formatters_js_1.formatDocumentSearchResults)(resultWithQuery);
+                    const formattedText = (0, index_js_2.formatDocumentSearchResults)(resultWithQuery);
                     return {
                         content: [{ type: 'text', text: formattedText }],
                     };
@@ -980,7 +1257,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         include_diversity: true,
                         diversity_max_hops: 2,
                     });
-                    const formattedText = (0, formatters_js_1.formatSearchResults)(result);
+                    const formattedText = (0, index_js_2.formatSearchResults)(result);
                     return {
                         content: [{ type: 'text', text: formattedText }],
                     };
@@ -995,7 +1272,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         const diversityMaxHops = toolArgs.diversity_max_hops || 2;
                         const truncateEvidence = toolArgs.truncate_evidence !== false; // Default true
                         const result = await client.getConceptDetails(toolArgs.concept_id, includeGrounding, includeDiversity, diversityMaxHops);
-                        const formattedText = (0, formatters_js_1.formatConceptDetails)(result, truncateEvidence);
+                        const formattedText = (0, index_js_2.formatConceptDetails)(result, truncateEvidence);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
@@ -1009,7 +1286,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             include_epistemic_status: toolArgs.include_epistemic_status,
                             exclude_epistemic_status: toolArgs.exclude_epistemic_status,
                         });
-                        const formattedText = (0, formatters_js_1.formatRelatedConcepts)(result);
+                        const formattedText = (0, index_js_2.formatRelatedConcepts)(result);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
@@ -1045,7 +1322,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                                 include_epistemic_status: toolArgs.include_epistemic_status,
                                 exclude_epistemic_status: toolArgs.exclude_epistemic_status,
                             });
-                            const formattedText = (0, formatters_js_1.formatConnectionPaths)(result);
+                            const formattedText = (0, index_js_2.formatConnectionPaths)(result);
                             return {
                                 content: [{ type: 'text', text: formattedText }],
                             };
@@ -1061,13 +1338,13 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     case 'list': {
                         const result = await client.listOntologies();
                         return {
-                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                            content: [{ type: 'text', text: (0, index_js_2.formatOntologyList)(result) }],
                         };
                     }
                     case 'info': {
                         const result = await client.getOntologyInfo(toolArgs.ontology_name);
                         return {
-                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                            content: [{ type: 'text', text: (0, index_js_2.formatOntologyInfo)(result) }],
                         };
                     }
                     case 'files': {
@@ -1076,12 +1353,111 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
+                    case 'create': {
+                        const result = await client.createOntology(toolArgs.ontology_name, toolArgs.description || '');
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'rename': {
+                        const result = await client.renameOntology(toolArgs.ontology_name, toolArgs.new_name);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'lifecycle': {
+                        const result = await client.updateOntologyLifecycle(toolArgs.ontology_name, toolArgs.lifecycle_state);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
                     case 'delete': {
                         const result = await client.deleteOntology(toolArgs.ontology_name, toolArgs.force || false);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
+                    // ADR-200 Phase 3a: Scoring & Annealing Control Surface
+                    case 'scores': {
+                        const result = await client.getOntologyScores(toolArgs.ontology_name);
+                        return {
+                            content: [{ type: 'text', text: (0, index_js_2.formatOntologyScores)(result) }],
+                        };
+                    }
+                    case 'score': {
+                        const result = await client.computeOntologyScores(toolArgs.ontology_name);
+                        return {
+                            content: [{ type: 'text', text: (0, index_js_2.formatOntologyScores)(result) }],
+                        };
+                    }
+                    case 'score_all': {
+                        const result = await client.computeAllOntologyScores();
+                        return {
+                            content: [{ type: 'text', text: (0, index_js_2.formatOntologyScores)(result) }],
+                        };
+                    }
+                    case 'candidates': {
+                        const result = await client.getOntologyCandidates(toolArgs.ontology_name, toolArgs.limit || 20);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'affinity': {
+                        const result = await client.getOntologyAffinity(toolArgs.ontology_name, toolArgs.limit || 10);
+                        return {
+                            content: [{ type: 'text', text: (0, index_js_2.formatOntologyAffinity)(result) }],
+                        };
+                    }
+                    case 'edges': {
+                        const result = await client.getOntologyEdges(toolArgs.ontology_name);
+                        return {
+                            content: [{ type: 'text', text: (0, index_js_2.formatOntologyEdges)(result) }],
+                        };
+                    }
+                    case 'reassign': {
+                        const result = await client.reassignSources(toolArgs.ontology_name, toolArgs.target_ontology, toolArgs.source_ids);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'dissolve': {
+                        const result = await client.dissolveOntology(toolArgs.ontology_name, toolArgs.target_ontology);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'proposals': {
+                        const result = await client.listProposals({
+                            status: toolArgs.status,
+                            proposal_type: toolArgs.proposal_type,
+                            ontology: toolArgs.ontology_name,
+                            limit: toolArgs.limit,
+                        });
+                        return {
+                            content: [{ type: 'text', text: (0, index_js_2.formatProposalList)(result) }],
+                        };
+                    }
+                    case 'proposal_review': {
+                        const reviewStatus = toolArgs.status;
+                        if (!reviewStatus || !['approved', 'rejected'].includes(reviewStatus)) {
+                            throw new Error('proposal_review requires status: "approved" or "rejected"');
+                        }
+                        const result = await client.reviewProposal(toolArgs.proposal_id, reviewStatus, toolArgs.notes);
+                        return {
+                            content: [{ type: 'text', text: (0, index_js_2.formatProposalDetail)(result) }],
+                        };
+                    }
+                    case 'annealing_cycle': {
+                        const result = await client.triggerAnnealingCycle({
+                            dry_run: toolArgs.dry_run,
+                            demotion_threshold: toolArgs.demotion_threshold,
+                            promotion_min_degree: toolArgs.promotion_min_degree,
+                            max_proposals: toolArgs.max_proposals,
+                        });
+                        return {
+                            content: [{ type: 'text', text: (0, index_js_2.formatAnnealingCycleResult)(result) }],
+                        };
+                    }
                     default:
                         throw new Error(`Unknown ontology action: ${action}`);
                 }
@@ -1091,14 +1467,14 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 switch (action) {
                     case 'status': {
                         const result = await client.getJobStatus(toolArgs.job_id);
-                        const formattedText = (0, formatters_js_1.formatJobStatus)(result);
+                        const formattedText = (0, index_js_2.formatJobStatus)(result);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
                     }
                     case 'list': {
                         const result = await client.listJobs(toolArgs.status, undefined, toolArgs.limit || 50);
-                        const formattedText = (0, formatters_js_1.formatJobList)(result);
+                        const formattedText = (0, index_js_2.formatJobList)(result);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
@@ -1115,6 +1491,49 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
+                    case 'delete': {
+                        const result = await client.deleteJob(toolArgs.job_id, {
+                            purge: true,
+                            force: toolArgs.force || false
+                        });
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'cleanup': {
+                        const result = await client.deleteJobs({
+                            dryRun: toolArgs.dry_run !== false && !toolArgs.confirm,
+                            confirm: toolArgs.confirm || false,
+                            status: toolArgs.status,
+                            system: toolArgs.system_only || false,
+                            olderThan: toolArgs.older_than,
+                            jobType: toolArgs.job_type
+                        });
+                        let output = '';
+                        if (result.dry_run) {
+                            output = `## Cleanup Preview (dry run)\n\n`;
+                            output += `Jobs matching filters: ${result.jobs_to_delete}\n\n`;
+                            if (result.jobs && result.jobs.length > 0) {
+                                output += `| Job ID | Type | Status | Created |\n`;
+                                output += `|--------|------|--------|--------|\n`;
+                                for (const job of result.jobs.slice(0, 20)) {
+                                    output += `| ${job.job_id.substring(0, 16)} | ${job.job_type} | ${job.status} | ${job.created_at} |\n`;
+                                }
+                                if (result.jobs.length > 20) {
+                                    output += `\n... and ${result.jobs.length - 20} more\n`;
+                                }
+                            }
+                            output += `\nTo delete, use confirm: true`;
+                        }
+                        else {
+                            output = `## Cleanup Complete\n\n`;
+                            output += `Jobs deleted: ${result.jobs_deleted}\n`;
+                            output += `\n${result.message}`;
+                        }
+                        return {
+                            content: [{ type: 'text', text: output }],
+                        };
+                    }
                     default:
                         throw new Error(`Unknown job action: ${action}`);
                 }
@@ -1201,7 +1620,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             content: [
                                 {
                                     type: 'text',
-                                    text: (0, formatters_js_1.formatInspectFileResult)(result),
+                                    text: (0, index_js_2.formatInspectFileResult)(result),
                                 },
                             ],
                         };
@@ -1297,7 +1716,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             content: [
                                 {
                                     type: 'text',
-                                    text: (0, formatters_js_1.formatIngestFileResult)(result),
+                                    text: (0, index_js_2.formatIngestFileResult)(result),
                                 },
                             ],
                         };
@@ -1380,7 +1799,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             content: [
                                 {
                                     type: 'text',
-                                    text: (0, formatters_js_1.formatIngestDirectoryResult)(result),
+                                    text: (0, index_js_2.formatIngestDirectoryResult)(result),
                                 },
                             ],
                         };
@@ -1449,7 +1868,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     case 'list': {
                         const statusFilter = toolArgs.status_filter;
                         const result = await client.listEpistemicStatus(statusFilter);
-                        const output = (0, formatters_js_1.formatEpistemicStatusList)(result);
+                        const output = (0, index_js_2.formatEpistemicStatusList)(result);
                         return {
                             content: [{ type: 'text', text: output }],
                         };
@@ -1460,7 +1879,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             throw new Error('relationship_type is required for show action');
                         }
                         const result = await client.getEpistemicStatus(relationshipType);
-                        const output = (0, formatters_js_1.formatEpistemicStatusDetails)(result);
+                        const output = (0, index_js_2.formatEpistemicStatusDetails)(result);
                         return {
                             content: [{ type: 'text', text: output }],
                         };
@@ -1474,7 +1893,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             store: store,
                             verbose: verbose,
                         });
-                        const output = (0, formatters_js_1.formatEpistemicStatusMeasurement)(result);
+                        const output = (0, index_js_2.formatEpistemicStatusMeasurement)(result);
                         return {
                             content: [{ type: 'text', text: output }],
                         };
@@ -1492,7 +1911,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     max_candidates: toolArgs.max_candidates || 20,
                     max_hops: toolArgs.max_hops || 2,
                 });
-                const formattedText = (0, formatters_js_1.formatPolarityAxisResults)(result);
+                const formattedText = (0, index_js_2.formatPolarityAxisResults)(result);
                 return {
                     content: [{ type: 'text', text: formattedText }],
                 };
@@ -1596,7 +2015,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             limit: toolArgs.limit || 50,
                             offset: toolArgs.offset || 0,
                         });
-                        const formattedText = (0, formatters_js_1.formatDocumentList)(result);
+                        const formattedText = (0, index_js_2.formatDocumentList)(result);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
@@ -1607,7 +2026,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                             throw new Error('document_id is required for show action');
                         }
                         const result = await client.getDocumentContent(documentId);
-                        const formattedText = (0, formatters_js_1.formatDocumentContent)(result);
+                        const formattedText = (0, index_js_2.formatDocumentContent)(result);
                         return {
                             content: [{ type: 'text', text: formattedText }],
                         };
@@ -1636,13 +2055,13 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                                     });
                                 }
                             }
-                            const formattedText = (0, formatters_js_1.formatDocumentConceptsDetailed)(result, conceptDetails);
+                            const formattedText = (0, index_js_2.formatDocumentConceptsDetailed)(result, conceptDetails);
                             return {
                                 content: [{ type: 'text', text: formattedText }],
                             };
                         }
                         else {
-                            const formattedText = (0, formatters_js_1.formatDocumentConcepts)(result);
+                            const formattedText = (0, index_js_2.formatDocumentConcepts)(result);
                             return {
                                 content: [{ type: 'text', text: formattedText }],
                             };
@@ -1652,6 +2071,175 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         throw new Error(`Unknown document action: ${action}`);
                 }
             }
+            // ADR-089 Phase 3a: Graph CRUD Tool Handler (Refactored)
+            case 'graph': {
+                const action = toolArgs.action;
+                const entity = toolArgs.entity;
+                // Entity required for all actions except queue
+                if (action !== 'queue' && !entity) {
+                    throw new Error('entity is required (concept or edge)');
+                }
+                // Create executor instance for this request
+                const executor = new graph_operations_js_1.GraphOperationExecutor(client);
+                switch (action) {
+                    case 'create': {
+                        if (entity === 'concept') {
+                            const result = await executor.createConcept({
+                                label: toolArgs.label,
+                                ontology: toolArgs.ontology,
+                                description: toolArgs.description,
+                                search_terms: toolArgs.search_terms,
+                                matching_mode: toolArgs.matching_mode,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphConceptResult)(result.data, 'create') }],
+                            };
+                        }
+                        else if (entity === 'edge') {
+                            const result = await executor.createEdge({
+                                from_concept_id: toolArgs.from_concept_id,
+                                from_label: toolArgs.from_label,
+                                to_concept_id: toolArgs.to_concept_id,
+                                to_label: toolArgs.to_label,
+                                relationship_type: toolArgs.relationship_type,
+                                category: toolArgs.category,
+                                confidence: toolArgs.confidence,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphEdgeResult)(result.data, 'create') }],
+                            };
+                        }
+                        else {
+                            throw new Error(`Unknown entity type: ${entity}`);
+                        }
+                    }
+                    case 'list': {
+                        if (entity === 'concept') {
+                            const result = await executor.listConcepts({
+                                ontology: toolArgs.ontology,
+                                label_contains: toolArgs.label_contains,
+                                creation_method: toolArgs.creation_method,
+                                offset: toolArgs.offset,
+                                limit: toolArgs.limit,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphConceptList)(result.data) }],
+                            };
+                        }
+                        else if (entity === 'edge') {
+                            const result = await executor.listEdges({
+                                from_concept_id: toolArgs.from_concept_id,
+                                from_label: toolArgs.from_label,
+                                to_concept_id: toolArgs.to_concept_id,
+                                to_label: toolArgs.to_label,
+                                relationship_type: toolArgs.relationship_type,
+                                category: toolArgs.category,
+                                source: toolArgs.source,
+                                offset: toolArgs.offset,
+                                limit: toolArgs.limit,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphEdgeList)(result.data) }],
+                            };
+                        }
+                        else {
+                            throw new Error(`Unknown entity type: ${entity}`);
+                        }
+                    }
+                    case 'edit': {
+                        if (entity === 'concept') {
+                            const result = await executor.editConcept({
+                                concept_id: toolArgs.concept_id,
+                                label: toolArgs.label,
+                                description: toolArgs.description,
+                                search_terms: toolArgs.search_terms,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphConceptResult)(result.data, 'edit') }],
+                            };
+                        }
+                        else if (entity === 'edge') {
+                            const result = await executor.editEdge({
+                                from_concept_id: toolArgs.from_concept_id,
+                                from_label: toolArgs.from_label,
+                                to_concept_id: toolArgs.to_concept_id,
+                                to_label: toolArgs.to_label,
+                                relationship_type: toolArgs.relationship_type,
+                                confidence: toolArgs.confidence,
+                                category: toolArgs.category,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphEdgeResult)(result.data, 'edit') }],
+                            };
+                        }
+                        else {
+                            throw new Error(`Unknown entity type: ${entity}`);
+                        }
+                    }
+                    case 'delete': {
+                        if (entity === 'concept') {
+                            const result = await executor.deleteConcept({
+                                concept_id: toolArgs.concept_id,
+                                cascade: toolArgs.cascade,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphConceptResult)(result.data, 'delete') }],
+                            };
+                        }
+                        else if (entity === 'edge') {
+                            const result = await executor.deleteEdge({
+                                from_concept_id: toolArgs.from_concept_id,
+                                from_label: toolArgs.from_label,
+                                to_concept_id: toolArgs.to_concept_id,
+                                to_label: toolArgs.to_label,
+                                relationship_type: toolArgs.relationship_type,
+                            });
+                            if (!result.success)
+                                throw new Error(result.error);
+                            return {
+                                content: [{ type: 'text', text: (0, index_js_2.formatGraphEdgeResult)(result.data, 'delete') }],
+                            };
+                        }
+                        else {
+                            throw new Error(`Unknown entity type: ${entity}`);
+                        }
+                    }
+                    case 'queue': {
+                        const operations = toolArgs.operations;
+                        const continueOnError = toolArgs.continue_on_error === true;
+                        if (!operations || !Array.isArray(operations)) {
+                            throw new Error('operations array is required for queue action');
+                        }
+                        if (operations.length === 0) {
+                            throw new Error('operations array cannot be empty');
+                        }
+                        if (operations.length > 20) {
+                            throw new Error(`Queue too large: ${operations.length} operations (max 20)`);
+                        }
+                        const queueResult = await executor.executeQueue(operations, continueOnError);
+                        const formattedOutput = (0, index_js_2.formatGraphQueueResult)(queueResult, operations.length);
+                        return {
+                            content: [{ type: 'text', text: formattedOutput }],
+                        };
+                    }
+                    default:
+                        throw new Error(`Unknown graph action: ${action}. Use: create, edit, delete, list, or queue`);
+                }
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }