@tacitai/mcp-server 0.1.1 → 0.3.0

package/dist/tools/lake.js

@@ -0,0 +1,1017 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Lake tools — CLI wrappers for data lake source, sync, proposal,
+ * classification, catalog, taxonomy, and subject-classification operations
+ * on the Axum REST API.
+ *
+ * Routes (Axum, all under /api/v1/org/lake):
+ *   POST   /onboard
+ *   GET    /sources
+ *   DELETE /sources/:id
+ *   GET    /status
+ *   POST   /sync
+ *   GET    /proposals
+ *   POST   /proposals/confirm
+ *   POST   /classify
+ *   POST   /catalog/:id/reclassify
+ *   POST   /writeback
+ *   GET    /catalog
+ *   GET    /catalog/:id
+ *   DELETE /catalog/:id
+ *   POST   /ingest
+ *   GET    /taxonomy
+ *   POST   /taxonomy/seed
+ *   POST   /taxonomy/nodes
+ *   POST   /catalog/:id/subject
+ *   POST   /catalog/subject/bulk
+ */
+import { z } from 'zod';
+import { getClient, TacitApiError, TokenExpiredError } from '../client.js';
+function apiErrorResult(err, toolName) {
+    if (err instanceof TokenExpiredError) {
+        return {
+            content: [{ type: 'text', text: err.message }],
+            isError: true,
+        };
+    }
+    if (err instanceof TacitApiError) {
+        return { content: [{ type: 'text', text: `API error ${err.statusCode} on ${toolName}: ${err.body}` }], isError: true };
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+}
+// ─── tacit_lake_register_source ─────────────────────────────────────────────
+export const registerSourceInputSchema = z.object({
+    source: z.string().min(1).describe('Source path / s3:// URI / git remote'),
+    kind: z.string().optional().describe('Source kind: localfs|s3|git; inferred from source if omitted'),
+    sync_mode: z.string().optional().describe('Sync mode: manual|scheduled|event; defaults to MANUAL'),
+    interval: z.number().optional().describe('Scheduled-only interval in seconds'),
+    write_back: z.boolean().optional().describe('Enable Mode B write-back'),
+    write_back_path: z.string().optional().describe('Repo-relative partition for write-back'),
+    default_kb_collection: z.string().optional().describe('Per-source default KB collection name'),
+    webhook_secret: z.string().optional().describe('HMAC-SHA256 secret for event-driven webhook sync (LAKE-18)'),
+});
+export const REGISTER_SOURCE_TOOL_DEF = {
+    name: 'tacit_lake_register_source',
+    description: 'Register a new data lake source (onboard). Route: POST /api/v1/org/lake/onboard.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            source: { type: 'string', description: 'Source path / s3:// URI / git remote' },
+            kind: { type: 'string', description: 'Source kind: localfs|s3|git; inferred from source if omitted' },
+            sync_mode: { type: 'string', description: 'Sync mode: manual|scheduled|event; defaults to MANUAL' },
+            interval: { type: 'number', description: 'Scheduled-only interval in seconds' },
+            write_back: { type: 'boolean', description: 'Enable Mode B write-back' },
+            write_back_path: { type: 'string', description: 'Repo-relative partition for write-back' },
+            default_kb_collection: { type: 'string', description: 'Per-source default KB collection name' },
+            webhook_secret: { type: 'string', description: 'HMAC-SHA256 secret for event-driven webhook sync (LAKE-18)' },
+        },
+        required: ['source'],
+    },
+};
+export function buildRegisterSourceRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { source: input.source };
+                if (input.kind !== undefined)
+                    body['kind'] = input.kind;
+                if (input.sync_mode !== undefined)
+                    body['sync_mode'] = input.sync_mode;
+                if (input.interval !== undefined)
+                    body['interval'] = input.interval;
+                if (input.write_back !== undefined)
+                    body['write_back'] = input.write_back;
+                if (input.write_back_path !== undefined)
+                    body['write_back_path'] = input.write_back_path;
+                if (input.default_kb_collection !== undefined)
+                    body['default_kb_collection'] = input.default_kb_collection;
+                if (input.webhook_secret !== undefined)
+                    body['webhook_secret'] = input.webhook_secret;
+                const result = await client.post('/api/v1/org/lake/onboard', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_register_source');
+            }
+        },
+    };
+}
+export async function handleRegisterSource(args) {
+    const parsed = registerSourceInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildRegisterSourceRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_list_sources ─────────────────────────────────────────────────
+export const listSourcesInputSchema = z.object({});
+export const LIST_SOURCES_TOOL_DEF = {
+    name: 'tacit_lake_list_sources',
+    description: 'List registered data lake sources for the current workspace. Route: GET /api/v1/org/lake/sources.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+};
+export function buildListSourcesRequest(client, _input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get('/api/v1/org/lake/sources');
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_list_sources');
+            }
+        },
+    };
+}
+export async function handleListSources(args) {
+    const parsed = listSourcesInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildListSourcesRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_deregister_source ───────────────────────────────────────────
+export const deregisterSourceInputSchema = z.object({
+    source_id: z.string().uuid().describe('Source to deregister'),
+});
+export const DEREGISTER_SOURCE_TOOL_DEF = {
+    name: 'tacit_lake_deregister_source',
+    description: 'Deregister a data lake source (soft-delete). Archives catalog entries and clears sync queue. Destructive — T3 approval required. Route: DELETE /api/v1/org/lake/sources/{source_id}.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            source_id: { type: 'string', description: 'Source to deregister' },
+        },
+        required: ['source_id'],
+    },
+};
+export function buildDeregisterSourceRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.delete(`/api/v1/org/lake/sources/${input.source_id}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_deregister_source');
+            }
+        },
+    };
+}
+export async function handleDeregisterSource(args) {
+    const parsed = deregisterSourceInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildDeregisterSourceRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_sync_status ──────────────────────────────────────────────────
+export const syncStatusInputSchema = z.object({
+    source_id: z.string().uuid().optional().describe('Filter by source ID'),
+});
+export const SYNC_STATUS_TOOL_DEF = {
+    name: 'tacit_lake_sync_status',
+    description: 'Check data lake sync status — running runs, active catalog rows, latest run status. Route: GET /api/v1/org/lake/status.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            source_id: { type: 'string', description: 'Filter by source ID' },
+        },
+        required: [],
+    },
+};
+export function buildSyncStatusRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const params = {};
+                if (input.source_id !== undefined)
+                    params['source_id'] = input.source_id;
+                const result = await client.get('/api/v1/org/lake/status', params);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_sync_status');
+            }
+        },
+    };
+}
+export async function handleSyncStatus(args) {
+    const parsed = syncStatusInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildSyncStatusRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_trigger_sync ─────────────────────────────────────────────────
+export const triggerSyncInputSchema = z.object({
+    source_id: z.string().uuid().describe('Source to sync'),
+    confirm_deletions: z.boolean().optional().describe('Confirm deletion of removed source files'),
+});
+export const TRIGGER_SYNC_TOOL_DEF = {
+    name: 'tacit_lake_trigger_sync',
+    description: 'Trigger an incremental sync from a registered data lake source. Route: POST /api/v1/org/lake/sync.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            source_id: { type: 'string', description: 'Source to sync' },
+            confirm_deletions: { type: 'boolean', description: 'Confirm deletion of removed source files' },
+        },
+        required: ['source_id'],
+    },
+};
+export function buildTriggerSyncRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { source_id: input.source_id };
+                if (input.confirm_deletions !== undefined)
+                    body['confirm_deletions'] = input.confirm_deletions;
+                const result = await client.post('/api/v1/org/lake/sync', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_trigger_sync');
+            }
+        },
+    };
+}
+export async function handleTriggerSync(args) {
+    const parsed = triggerSyncInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildTriggerSyncRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_list_proposals ───────────────────────────────────────────────
+export const listProposalsInputSchema = z.object({});
+export const LIST_PROPOSALS_TOOL_DEF = {
+    name: 'tacit_lake_list_proposals',
+    description: 'List pending org-structure placement proposals from the data lake bridge. Route: GET /api/v1/org/lake/proposals.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+};
+export function buildListProposalsRequest(client, _input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get('/api/v1/org/lake/proposals');
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_list_proposals');
+            }
+        },
+    };
+}
+export async function handleListProposals(args) {
+    const parsed = listProposalsInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildListProposalsRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_confirm_proposal ─────────────────────────────────────────────
+export const confirmProposalInputSchema = z.object({
+    proposal_id: z.string().uuid().describe('Proposal to confirm'),
+});
+export const CONFIRM_PROPOSAL_TOOL_DEF = {
+    name: 'tacit_lake_confirm_proposal',
+    description: 'Confirm a placement proposal, applying the org-structure link. Route: POST /api/v1/org/lake/proposals/confirm.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            proposal_id: { type: 'string', description: 'Proposal to confirm' },
+        },
+        required: ['proposal_id'],
+    },
+};
+export function buildConfirmProposalRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.post('/api/v1/org/lake/proposals/confirm', { proposal_id: input.proposal_id });
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_confirm_proposal');
+            }
+        },
+    };
+}
+export async function handleConfirmProposal(args) {
+    const parsed = confirmProposalInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildConfirmProposalRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_classify ─────────────────────────────────────────────────────
+export const classifyInputSchema = z.object({
+    source_uri: z.string().min(1).describe('URI of the document to classify'),
+    content: z.string().optional().describe('Document content for classification'),
+});
+export const CLASSIFY_TOOL_DEF = {
+    name: 'tacit_lake_classify',
+    description: 'Run ad-hoc classification on a document URI and optional content to get a placement proposal. Route: POST /api/v1/org/lake/classify.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            source_uri: { type: 'string', description: 'URI of the document to classify' },
+            content: { type: 'string', description: 'Document content for classification' },
+        },
+        required: ['source_uri'],
+    },
+};
+export function buildClassifyRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { source_uri: input.source_uri };
+                if (input.content !== undefined)
+                    body['content'] = input.content;
+                const result = await client.post('/api/v1/org/lake/classify', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_classify');
+            }
+        },
+    };
+}
+export async function handleClassify(args) {
+    const parsed = classifyInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildClassifyRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_reclassify ───────────────────────────────────────────────────
+export const reclassifyInputSchema = z.object({
+    catalog_id: z.string().uuid().describe('Catalog item to reclassify'),
+    proposed_portfolio: z.string().optional().describe('New portfolio placement'),
+    proposed_program: z.string().optional().describe('New program placement'),
+    proposed_domain_id: z.string().optional().describe('New domain ID placement'),
+});
+export const RECLASSIFY_TOOL_DEF = {
+    name: 'tacit_lake_reclassify',
+    description: 'Create a reclassification proposal to move a catalog item to a different placement. Route: POST /api/v1/org/lake/catalog/{catalog_id}/reclassify.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            catalog_id: { type: 'string', description: 'Catalog item to reclassify' },
+            proposed_portfolio: { type: 'string', description: 'New portfolio placement' },
+            proposed_program: { type: 'string', description: 'New program placement' },
+            proposed_domain_id: { type: 'string', description: 'New domain ID placement' },
+        },
+        required: ['catalog_id'],
+    },
+};
+export function buildReclassifyRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = {};
+                if (input.proposed_portfolio !== undefined)
+                    body['proposed_portfolio'] = input.proposed_portfolio;
+                if (input.proposed_program !== undefined)
+                    body['proposed_program'] = input.proposed_program;
+                if (input.proposed_domain_id !== undefined)
+                    body['proposed_domain_id'] = input.proposed_domain_id;
+                const result = await client.post(`/api/v1/org/lake/catalog/${input.catalog_id}/reclassify`, body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_reclassify');
+            }
+        },
+    };
+}
+export async function handleReclassify(args) {
+    const parsed = reclassifyInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildReclassifyRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_writeback ────────────────────────────────────────────────────
+export const writebackInputSchema = z.object({
+    source_id: z.string().uuid().describe('Source to write back to'),
+    artifact_id: z.string().uuid().describe('Artifact to write back'),
+    target_folder: z.string().optional().describe('Repo-relative folder to write into (overrides write_back_path)'),
+    slug: z.string().optional().describe('Filename slug (without extension); defaults to artifact_id'),
+    frontmatter: z.object({
+        subject: z.string().optional(),
+        title: z.string().optional(),
+        supersedes: z.string().uuid().optional(),
+        sensitivity: z.string().optional(),
+        status: z.string().optional(),
+    }).optional().describe('YAML frontmatter overrides for the written file (LAKE-18)'),
+});
+export const WRITEBACK_TOOL_DEF = {
+    name: 'tacit_lake_writeback',
+    description: 'Write back an artifact to its source Git repository via the LakeWriter. Route: POST /api/v1/org/lake/writeback.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            source_id: { type: 'string', description: 'Source to write back to' },
+            artifact_id: { type: 'string', description: 'Artifact to write back' },
+            target_folder: { type: 'string', description: 'Repo-relative folder to write into (overrides write_back_path)' },
+            slug: { type: 'string', description: 'Filename slug (without extension); defaults to artifact_id' },
+            frontmatter: { type: 'object', description: 'YAML frontmatter overrides: subject, title, supersedes, sensitivity, status' },
+        },
+        required: ['source_id', 'artifact_id'],
+    },
+};
+export function buildWritebackRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = {
+                    source_id: input.source_id,
+                    artifact_id: input.artifact_id,
+                };
+                if (input.target_folder !== undefined)
+                    body['target_folder'] = input.target_folder;
+                if (input.slug !== undefined)
+                    body['slug'] = input.slug;
+                if (input.frontmatter !== undefined)
+                    body['frontmatter'] = input.frontmatter;
+                const result = await client.post('/api/v1/org/lake/writeback', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_writeback');
+            }
+        },
+    };
+}
+export async function handleWriteback(args) {
+    const parsed = writebackInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildWritebackRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_browse_catalog ───────────────────────────────────────────────
+export const browseCatalogInputSchema = z.object({
+    limit: z.number().optional().describe('Max items to return'),
+    offset: z.number().optional().describe('Pagination offset'),
+    origin: z.string().optional().describe('Filter by origin'),
+    catalog_status: z.string().optional().describe('Filter by catalog status'),
+    content_type: z.string().optional().describe('Filter by content type'),
+    source_id: z.string().uuid().optional().describe('Filter by source ID'),
+    q: z.string().optional().describe('Search query'),
+    subject_id: z.string().uuid().optional().describe('Filter by subject node ID'),
+    subject_needs_review: z.boolean().optional().describe('Filter by review status'),
+    subject_layer: z.string().optional().describe('Filter by subject layer'),
+});
+export const BROWSE_CATALOG_TOOL_DEF = {
+    name: 'tacit_lake_browse_catalog',
+    description: 'Browse the data lake catalog with filtering and pagination. Route: GET /api/v1/org/lake/catalog.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            limit: { type: 'number', description: 'Max items to return' },
+            offset: { type: 'number', description: 'Pagination offset' },
+            origin: { type: 'string', description: 'Filter by origin' },
+            catalog_status: { type: 'string', description: 'Filter by catalog status' },
+            content_type: { type: 'string', description: 'Filter by content type' },
+            source_id: { type: 'string', description: 'Filter by source ID' },
+            q: { type: 'string', description: 'Search query' },
+            subject_id: { type: 'string', description: 'Filter by subject node ID' },
+            subject_needs_review: { type: 'boolean', description: 'Filter by review status' },
+            subject_layer: { type: 'string', description: 'Filter by subject layer' },
+        },
+        required: [],
+    },
+};
+export function buildBrowseCatalogRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const params = {};
+                if (input.limit !== undefined)
+                    params['limit'] = input.limit;
+                if (input.offset !== undefined)
+                    params['offset'] = input.offset;
+                if (input.origin !== undefined)
+                    params['origin'] = input.origin;
+                if (input.catalog_status !== undefined)
+                    params['catalog_status'] = input.catalog_status;
+                if (input.content_type !== undefined)
+                    params['content_type'] = input.content_type;
+                if (input.source_id !== undefined)
+                    params['source_id'] = input.source_id;
+                if (input.q !== undefined)
+                    params['q'] = input.q;
+                if (input.subject_id !== undefined)
+                    params['subject_id'] = input.subject_id;
+                if (input.subject_needs_review !== undefined)
+                    params['subject_needs_review'] = input.subject_needs_review;
+                if (input.subject_layer !== undefined)
+                    params['subject_layer'] = input.subject_layer;
+                const result = await client.get('/api/v1/org/lake/catalog', params);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_browse_catalog');
+            }
+        },
+    };
+}
+export async function handleBrowseCatalog(args) {
+    const parsed = browseCatalogInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildBrowseCatalogRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_catalog_detail ───────────────────────────────────────────────
+export const catalogDetailInputSchema = z.object({
+    catalog_id: z.string().uuid().describe('Catalog item UUID'),
+});
+export const CATALOG_DETAIL_TOOL_DEF = {
+    name: 'tacit_lake_catalog_detail',
+    description: 'Get full detail for a catalog item, including source name and linked proposals. Route: GET /api/v1/org/lake/catalog/{catalog_id}.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            catalog_id: { type: 'string', description: 'Catalog item UUID' },
+        },
+        required: ['catalog_id'],
+    },
+};
+export function buildCatalogDetailRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get(`/api/v1/org/lake/catalog/${input.catalog_id}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_catalog_detail');
+            }
+        },
+    };
+}
+export async function handleCatalogDetail(args) {
+    const parsed = catalogDetailInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildCatalogDetailRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_delete_catalog_item ──────────────────────────────────────────
+export const deleteCatalogItemInputSchema = z.object({
+    catalog_id: z.string().uuid().describe('Catalog item to delete'),
+});
+export const DELETE_CATALOG_ITEM_TOOL_DEF = {
+    name: 'tacit_lake_delete_catalog_item',
+    description: 'Soft-delete a catalog item (sets status to OPERATOR_DELETED). Reversible. Route: DELETE /api/v1/org/lake/catalog/{catalog_id}.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            catalog_id: { type: 'string', description: 'Catalog item to delete' },
+        },
+        required: ['catalog_id'],
+    },
+};
+export function buildDeleteCatalogItemRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.delete(`/api/v1/org/lake/catalog/${input.catalog_id}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_delete_catalog_item');
+            }
+        },
+    };
+}
+export async function handleDeleteCatalogItem(args) {
+    const parsed = deleteCatalogItemInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildDeleteCatalogItemRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_ingest ───────────────────────────────────────────────────────
+export const ingestInputSchema = z.object({
+    source_uri: z.string().min(1).describe('URI identifying the document'),
+    content: z.string().min(1).describe('Document content'),
+    content_type: z.string().optional().describe('MIME type of the content'),
+});
+export const INGEST_TOOL_DEF = {
+    name: 'tacit_lake_ingest',
+    description: 'Ingest a single document into the data lake without a registered source. Creates a TACIT-origin catalog entry. Route: POST /api/v1/org/lake/ingest.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            source_uri: { type: 'string', description: 'URI identifying the document' },
+            content: { type: 'string', description: 'Document content' },
+            content_type: { type: 'string', description: 'MIME type of the content' },
+        },
+        required: ['source_uri', 'content'],
+    },
+};
+export function buildIngestRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { source_uri: input.source_uri, content: input.content };
+                if (input.content_type !== undefined)
+                    body['content_type'] = input.content_type;
+                const result = await client.post('/api/v1/org/lake/ingest', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_ingest');
+            }
+        },
+    };
+}
+export async function handleIngest(args) {
+    const parsed = ingestInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildIngestRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_taxonomy_browse ──────────────────────────────────────────────
+export const taxonomyBrowseInputSchema = z.object({
+    layer: z.string().optional().describe('Filter by layer: COMPANY, DOMAIN, DIMENSION'),
+    parent_id: z.string().uuid().optional().describe('Filter by parent node ID'),
+});
+export const TAXONOMY_BROWSE_TOOL_DEF = {
+    name: 'tacit_lake_taxonomy_browse',
+    description: 'Browse the lake classification taxonomy tree for the current workspace. Route: GET /api/v1/org/lake/taxonomy.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            layer: { type: 'string', description: 'Filter by layer: COMPANY, DOMAIN, DIMENSION' },
+            parent_id: { type: 'string', description: 'Filter by parent node ID' },
+        },
+        required: [],
+    },
+};
+export function buildTaxonomyBrowseRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const params = {};
+                if (input.layer !== undefined)
+                    params['layer'] = input.layer;
+                if (input.parent_id !== undefined)
+                    params['parent_id'] = input.parent_id;
+                const result = await client.get('/api/v1/org/lake/taxonomy', params);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_taxonomy_browse');
+            }
+        },
+    };
+}
+export async function handleTaxonomyBrowse(args) {
+    const parsed = taxonomyBrowseInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildTaxonomyBrowseRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_taxonomy_seed ────────────────────────────────────────────────
+export const taxonomySeedInputSchema = z.object({});
+export const TAXONOMY_SEED_TOOL_DEF = {
+    name: 'tacit_lake_taxonomy_seed',
+    description: 'Seed the DOMAIN layer of the taxonomy from built-in domain schema definitions. Idempotent — safe to call multiple times. Route: POST /api/v1/org/lake/taxonomy/seed.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+};
+export function buildTaxonomySeedRequest(client, _input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.post('/api/v1/org/lake/taxonomy/seed', {});
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_taxonomy_seed');
+            }
+        },
+    };
+}
+export async function handleTaxonomySeed(args) {
+    const parsed = taxonomySeedInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildTaxonomySeedRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_taxonomy_upsert_node ─────────────────────────────────────────
+export const taxonomyUpsertNodeInputSchema = z.object({
+    slug: z.string().min(1).describe('Unique slug for the node within its layer'),
+    name: z.string().min(1).describe('Display name'),
+    layer: z.enum(['COMPANY', 'DOMAIN', 'DIMENSION']).describe('Taxonomy layer'),
+    parent_id: z.string().uuid().optional().describe('Parent node ID'),
+    description: z.string().optional().describe('Node description'),
+    aliases: z.array(z.string()).optional().describe('Alternative names for matching'),
+});
+export const TAXONOMY_UPSERT_NODE_TOOL_DEF = {
+    name: 'tacit_lake_taxonomy_upsert_node',
+    description: 'Create or update a taxonomy classification node. Route: POST /api/v1/org/lake/taxonomy/nodes.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            slug: { type: 'string', description: 'Unique slug for the node within its layer' },
+            name: { type: 'string', description: 'Display name' },
+            layer: { type: 'string', enum: ['COMPANY', 'DOMAIN', 'DIMENSION'], description: 'Taxonomy layer' },
+            parent_id: { type: 'string', description: 'Parent node ID' },
+            description: { type: 'string', description: 'Node description' },
+            aliases: { type: 'array', items: { type: 'string' }, description: 'Alternative names for matching' },
+        },
+        required: ['slug', 'name', 'layer'],
+    },
+};
+export function buildTaxonomyUpsertNodeRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { slug: input.slug, name: input.name, layer: input.layer };
+                if (input.parent_id !== undefined)
+                    body['parent_id'] = input.parent_id;
+                if (input.description !== undefined)
+                    body['description'] = input.description;
+                if (input.aliases !== undefined)
+                    body['aliases'] = input.aliases;
+                const result = await client.post('/api/v1/org/lake/taxonomy/nodes', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_taxonomy_upsert_node');
+            }
+        },
+    };
+}
+export async function handleTaxonomyUpsertNode(args) {
+    const parsed = taxonomyUpsertNodeInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildTaxonomyUpsertNodeRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_classify_subject ─────────────────────────────────────────────
+export const classifySubjectInputSchema = z.object({
+    catalog_id: z.string().uuid().describe('Catalog item to classify'),
+    subject_id: z.string().uuid().describe('Target taxonomy node ID'),
+});
+export const CLASSIFY_SUBJECT_TOOL_DEF = {
+    name: 'tacit_lake_classify_subject',
+    description: 'Set the subject classification of a specific catalog item (operator OVERRIDE). Route: POST /api/v1/org/lake/catalog/{catalog_id}/subject.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            catalog_id: { type: 'string', description: 'Catalog item to classify' },
+            subject_id: { type: 'string', description: 'Target taxonomy node ID' },
+        },
+        required: ['catalog_id', 'subject_id'],
+    },
+};
+export function buildClassifySubjectRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.post(`/api/v1/org/lake/catalog/${input.catalog_id}/subject`, {
+                    subject_id: input.subject_id,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_classify_subject');
+            }
+        },
+    };
+}
+export async function handleClassifySubject(args) {
+    const parsed = classifySubjectInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildClassifySubjectRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_reclassify_subjects ──────────────────────────────────────────
+export const reclassifySubjectsInputSchema = z.object({
+    subject_id: z.string().uuid().describe('Target taxonomy node ID'),
+    catalog_ids: z.array(z.string().uuid()).min(1).describe('Catalog item IDs to reclassify'),
+});
+export const RECLASSIFY_SUBJECTS_TOOL_DEF = {
+    name: 'tacit_lake_reclassify_subjects',
+    description: 'Propose bulk reclassification of catalog items to a new subject. Creates a workspace proposal requiring human approval (T3). Route: POST /api/v1/org/lake/catalog/subject/bulk.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            subject_id: { type: 'string', description: 'Target taxonomy node ID' },
+            catalog_ids: { type: 'array', items: { type: 'string' }, description: 'Catalog item IDs to reclassify' },
+        },
+        required: ['subject_id', 'catalog_ids'],
+    },
+};
+export function buildReclassifySubjectsRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.post('/api/v1/org/lake/catalog/subject/bulk', {
+                    subject_id: input.subject_id,
+                    catalog_ids: input.catalog_ids,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_reclassify_subjects');
+            }
+        },
+    };
+}
+export async function handleReclassifySubjects(args) {
+    const parsed = reclassifySubjectsInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildReclassifySubjectsRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_resolve ───────────────────────────────────────────────────────
+export const resolveInputSchema = z.object({
+    doc_id: z.string().optional().describe('Document identity UUID (highest priority)'),
+    sha256: z.string().optional().describe('Content SHA-256 hash'),
+    path: z.string().optional().describe('Source URI path (lowest priority)'),
+});
+export const RESOLVE_TOOL_DEF = {
+    name: 'tacit_lake_resolve',
+    description: 'Resolve a lake document by doc_id, sha256, or path (priority: doc_id > sha256 > path). Route: POST /api/v1/org/lake/resolve.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            doc_id: { type: 'string', description: 'Document identity UUID (highest priority)' },
+            sha256: { type: 'string', description: 'Content SHA-256 hash' },
+            path: { type: 'string', description: 'Source URI path (lowest priority)' },
+        },
+        required: [],
+    },
+};
+export function buildResolveRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.post('/api/v1/org/lake/resolve', {
+                    doc_id: input.doc_id,
+                    sha256: input.sha256,
+                    path: input.path,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_resolve');
+            }
+        },
+    };
+}
+export async function handleResolve(args) {
+    const parsed = resolveInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildResolveRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_lake_manifest ──────────────────────────────────────────────────────
+export const manifestInputSchema = z.object({
+    source_id: z.string().min(1).describe('Source UUID to read manifest from'),
+});
+export const MANIFEST_TOOL_DEF = {
+    name: 'tacit_lake_manifest',
+    description: 'Read the parsed .tacit-lake.yaml manifest for a source. Route: GET /api/v1/org/lake/sources/:source_id/manifest.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            source_id: { type: 'string', description: 'Source UUID to read manifest from' },
+        },
+        required: ['source_id'],
+    },
+};
+export function buildManifestRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get(`/api/v1/org/lake/sources/${encodeURIComponent(input.source_id)}/manifest`);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_lake_manifest');
+            }
+        },
+    };
+}
+export async function handleManifest(args) {
+    const parsed = manifestInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildManifestRequest(getClient(), parsed.data).execute();
+}
+export function registerLakeTools(server, getClientFn) {
+    server.tool('tacit_lake_register_source', REGISTER_SOURCE_TOOL_DEF.description, registerSourceInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildRegisterSourceRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_list_sources', LIST_SOURCES_TOOL_DEF.description, {}, async () => {
+        const client = await getClientFn();
+        return buildListSourcesRequest(client, {}).execute();
+    });
+    server.tool('tacit_lake_deregister_source', DEREGISTER_SOURCE_TOOL_DEF.description, deregisterSourceInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildDeregisterSourceRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_sync_status', SYNC_STATUS_TOOL_DEF.description, syncStatusInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildSyncStatusRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_trigger_sync', TRIGGER_SYNC_TOOL_DEF.description, triggerSyncInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildTriggerSyncRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_list_proposals', LIST_PROPOSALS_TOOL_DEF.description, {}, async () => {
+        const client = await getClientFn();
+        return buildListProposalsRequest(client, {}).execute();
+    });
+    server.tool('tacit_lake_confirm_proposal', CONFIRM_PROPOSAL_TOOL_DEF.description, confirmProposalInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildConfirmProposalRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_classify', CLASSIFY_TOOL_DEF.description, classifyInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildClassifyRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_reclassify', RECLASSIFY_TOOL_DEF.description, reclassifyInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildReclassifyRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_writeback', WRITEBACK_TOOL_DEF.description, writebackInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildWritebackRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_browse_catalog', BROWSE_CATALOG_TOOL_DEF.description, browseCatalogInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildBrowseCatalogRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_catalog_detail', CATALOG_DETAIL_TOOL_DEF.description, catalogDetailInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildCatalogDetailRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_delete_catalog_item', DELETE_CATALOG_ITEM_TOOL_DEF.description, deleteCatalogItemInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildDeleteCatalogItemRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_ingest', INGEST_TOOL_DEF.description, ingestInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildIngestRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_taxonomy_browse', TAXONOMY_BROWSE_TOOL_DEF.description, taxonomyBrowseInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildTaxonomyBrowseRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_taxonomy_seed', TAXONOMY_SEED_TOOL_DEF.description, {}, async () => {
+        const client = await getClientFn();
+        return buildTaxonomySeedRequest(client, {}).execute();
+    });
+    server.tool('tacit_lake_taxonomy_upsert_node', TAXONOMY_UPSERT_NODE_TOOL_DEF.description, taxonomyUpsertNodeInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildTaxonomyUpsertNodeRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_classify_subject', CLASSIFY_SUBJECT_TOOL_DEF.description, classifySubjectInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildClassifySubjectRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_reclassify_subjects', RECLASSIFY_SUBJECTS_TOOL_DEF.description, reclassifySubjectsInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildReclassifySubjectsRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_resolve', RESOLVE_TOOL_DEF.description, resolveInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildResolveRequest(client, args).execute();
+    });
+    server.tool('tacit_lake_manifest', MANIFEST_TOOL_DEF.description, manifestInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildManifestRequest(client, args).execute();
+    });
+}