@tacitai/mcp-server 0.1.0 → 0.2.0

package/dist/tools/artifacts.js

@@ -1,9 +1,8 @@
-"use strict";
 // SPDX-License-Identifier: MIT
 /**
  * Artifact tools:
  *   tacit_artifact_list    — GET  /api/v1/artifacts
- *   tacit_artifact_create  — POST /api/v1/artifacts  (career-scoped handler)
+ *   tacit_artifact_create  — POST /api/v1/artifacts
  *   tacit_artifact_update  — PATCH /api/v1/artifacts/:id
  *   tacit_artifact_publish — POST  /api/v1/artifacts/:id/publish
  *
@@ -16,54 +15,64 @@
  *   - artifact_kind is hardcoded server-side (GENERIC) — the client must NOT send it.
  *   - The artifact body is populated server-side from structured_metadata
  *     (e.g. full_posting_text); the client does NOT send a content field.
- *   - This tool always sends "domain":"CAREER" in the request body.
+ *   - domain defaults to GENERAL if omitted; caller may pass any valid domain.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ARTIFACT_PUBLISH_TOOL_DEF = exports.artifactPublishInputSchema = exports.ARTIFACT_UPDATE_TOOL_DEF = exports.artifactUpdateInputSchema = exports.ARTIFACT_CREATE_TOOL_DEF = exports.artifactCreateInputSchema = exports.ARTIFACT_LIST_TOOL_DEF = exports.artifactListInputSchema = void 0;
-exports.buildArtifactListRequest = buildArtifactListRequest;
-exports.handleArtifactList = handleArtifactList;
-exports.buildArtifactCreateRequest = buildArtifactCreateRequest;
-exports.handleArtifactCreate = handleArtifactCreate;
-exports.buildArtifactUpdateRequest = buildArtifactUpdateRequest;
-exports.handleArtifactUpdate = handleArtifactUpdate;
-exports.buildArtifactPublishRequest = buildArtifactPublishRequest;
-exports.handleArtifactPublish = handleArtifactPublish;
-const zod_1 = require("zod");
-const client_js_1 = require("../client.js");
+import { z } from 'zod';
+import { getClient } from '../client.js';
+import { apiErrorResult } from './errors.js';
 // ─── List ────────────────────────────────────────────────────────────────────
-exports.artifactListInputSchema = zod_1.z.object({
-    limit: zod_1.z.number().int().positive().optional().describe('Maximum artifacts to return'),
-    offset: zod_1.z.number().int().nonnegative().optional().describe('Pagination offset'),
-    status: zod_1.z.string().optional().describe('Filter by status (e.g. PUBLISHED, DRAFT)'),
+export const artifactListInputSchema = z.object({
+    q: z.string().optional().describe('Full-text search over title and body (websearch syntax); results include a snippet'),
+    origin: z.enum(['IMPORTED', 'SYNTHESIZED', 'WIKI_CONVERGENCE']).optional().describe('Filter by artifact origin'),
+    status: z.string().optional().describe('Filter by status — comma-separated (e.g. "DRAFT,UNDER_REVIEW,PUBLISHED,REJECTED")'),
+    portfolio_id: z.string().optional().describe('Filter by portfolio UUID'),
+    limit: z.number().int().positive().optional().describe('Maximum artifacts to return'),
+    offset: z.number().int().nonnegative().optional().describe('Pagination offset (retained for compatibility; ignored by the backend)'),
 });
-exports.ARTIFACT_LIST_TOOL_DEF = {
+export const ARTIFACT_LIST_TOOL_DEF = {
     name: 'tacit_artifact_list',
-    description: 'List artifacts from the Tacit workspace. Route: GET /api/v1/artifacts.',
+    description: 'List/search artifacts from the Tacit workspace. `q` runs a full-text search over title and body ' +
+        '(websearch syntax) and results include a snippet. Route: GET /api/v1/artifacts.',
     inputSchema: {
         type: 'object',
         properties: {
+            q: { type: 'string', description: 'Full-text search over title and body (websearch syntax); results include a snippet' },
+            origin: { type: 'string', enum: ['IMPORTED', 'SYNTHESIZED', 'WIKI_CONVERGENCE'] },
+            status: { type: 'string', description: 'Comma-separated: DRAFT,UNDER_REVIEW,PUBLISHED,REJECTED' },
+            portfolio_id: { type: 'string' },
             limit: { type: 'number', description: 'Maximum artifacts to return' },
-            offset: { type: 'number', description: 'Pagination offset' },
-            status: { type: 'string', description: 'Filter by status' },
+            offset: { type: 'number', description: 'Pagination offset (retained for compatibility; ignored by the backend)' },
         },
         required: [],
     },
 };
-function buildArtifactListRequest(client, input) {
+export function buildArtifactListRequest(client, input) {
     return {
         async execute() {
-            const { limit, offset, status } = input;
+            const { q, origin, status, portfolio_id, limit, offset } = input;
             try {
                 const params = {};
+                if (q)
+                    params['q'] = q;
+                if (origin)
+                    params['origin'] = origin;
+                if (status)
+                    params['status'] = status;
+                if (portfolio_id)
+                    params['portfolio_id'] = portfolio_id;
                 if (limit !== undefined)
                     params['limit'] = limit;
                 if (offset !== undefined)
                     params['offset'] = offset;
-                if (status)
-                    params['status'] = status;
-                // GET /api/v1/artifacts
-                const result = await client.get('/api/v1/artifacts', params);
-                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+                // GET /api/v1/artifacts — response is {artifacts: [...]} or bare array
+                const raw = await client.get('/api/v1/artifacts', params);
+                const result = Array.isArray(raw) ? raw : raw['artifacts'] ?? [];
+                const enriched = result.map((item) => {
+                    const rec = item;
+                    const url = client.webUrl('artifact', String(rec['id'] ?? ''));
+                    return url ? { ...rec, web_url: url } : rec;
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(enriched) }] };
             }
             catch (err) {
                 return apiErrorResult(err, '/api/v1/artifacts');
@@ -71,35 +80,36 @@ function buildArtifactListRequest(client, input) {
         },
     };
 }
-async function handleArtifactList(args) {
-    const parsed = exports.artifactListInputSchema.safeParse(args);
+export async function handleArtifactList(args) {
+    const parsed = artifactListInputSchema.safeParse(args);
     if (!parsed.success) {
         return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
     }
-    return buildArtifactListRequest((0, client_js_1.getClient)(), parsed.data).execute();
+    return buildArtifactListRequest(getClient(), parsed.data).execute();
 }
 // ─── Create ──────────────────────────────────────────────────────────────────
-exports.artifactCreateInputSchema = zod_1.z.object({
-    title: zod_1.z.string().min(1).describe('Artifact title'),
-    domain: zod_1.z.string().optional().describe('Domain (always overridden to CAREER by this tool)'),
-    portfolio_id: zod_1.z.string().min(1).describe('Portfolio to associate with (REQUIRED by the backend; 403 without it)'),
-    structured_metadata: zod_1.z
-        .record(zod_1.z.unknown())
+export const artifactCreateInputSchema = z.object({
+    title: z.string().min(1).describe('Artifact title'),
+    domain: z.string().optional().describe('Domain tag (e.g. CAREER, GENERAL, ENGINEERING, PRODUCT). Defaults to GENERAL if omitted.'),
+    portfolio_id: z.string().min(1).describe('Portfolio to associate with (REQUIRED by the backend; 403 without it)'),
+    structured_metadata: z
+        .record(z.unknown())
         .optional()
         .describe('Structured metadata; the artifact body is populated server-side from this (e.g. full_posting_text)'),
 });
-exports.ARTIFACT_CREATE_TOOL_DEF = {
+export const ARTIFACT_CREATE_TOOL_DEF = {
     name: 'tacit_artifact_create',
-    description: 'Create a career-scoped artifact in Tacit (always domain CAREER). ' +
-        'Accepts a title plus an optional structured_metadata object; portfolio_id is required. ' +
+    description: 'Create an artifact in Tacit. ' +
+        'Accepts a title, optional domain (CAREER, GENERAL, ENGINEERING, PRODUCT — defaults to GENERAL), ' +
+        'and an optional structured_metadata object; portfolio_id is required. ' +
         'The artifact body is populated server-side from structured_metadata (e.g. full_posting_text), ' +
         'and artifact_kind is hardcoded server-side — neither is sent by this tool. ' +
-        'Route: POST /api/v1/artifacts (handlers::artifacts_career::create_artifact).',
+        'Route: POST /api/v1/artifacts.',
     inputSchema: {
         type: 'object',
         properties: {
             title: { type: 'string', description: 'Artifact title' },
-            domain: { type: 'string', description: 'Domain (always CAREER for this tool)' },
+            domain: { type: 'string', description: 'Domain tag (e.g. CAREER, GENERAL, ENGINEERING, PRODUCT). Defaults to GENERAL.' },
             portfolio_id: { type: 'string', description: 'Portfolio to associate with (REQUIRED; 403 without it)' },
             structured_metadata: {
                 type: 'object',
@@ -109,16 +119,14 @@ exports.ARTIFACT_CREATE_TOOL_DEF = {
         required: ['title', 'portfolio_id'],
     },
 };
-function buildArtifactCreateRequest(client, input) {
+export function buildArtifactCreateRequest(client, input) {
     return {
         async execute() {
-            const { title, portfolio_id, structured_metadata } = input;
+            const { title, domain, portfolio_id, structured_metadata } = input;
             try {
-                // Backend CreateArtifactRequest accepts only title/domain/output_format/portfolio_id/structured_metadata.
-                // artifact_kind is hardcoded server-side; the body comes from structured_metadata.full_posting_text.
                 const body = {
                     title,
-                    domain: 'CAREER',
+                    domain: (domain ?? 'general').toLowerCase(),
                     portfolio_id,
                 };
                 if (structured_metadata !== undefined)
@@ -133,35 +141,36 @@ function buildArtifactCreateRequest(client, input) {
         },
     };
 }
-async function handleArtifactCreate(args) {
-    const parsed = exports.artifactCreateInputSchema.safeParse(args);
+export async function handleArtifactCreate(args) {
+    const parsed = artifactCreateInputSchema.safeParse(args);
     if (!parsed.success) {
         return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
     }
-    return buildArtifactCreateRequest((0, client_js_1.getClient)(), parsed.data).execute();
+    return buildArtifactCreateRequest(getClient(), parsed.data).execute();
 }
 // ─── Update ──────────────────────────────────────────────────────────────────
-exports.artifactUpdateInputSchema = zod_1.z.object({
-    id: zod_1.z.string().min(1).describe('Artifact UUID to update'),
-    title: zod_1.z.string().optional().describe('New title'),
-    content: zod_1.z.string().optional().describe('New content body'),
-    tags: zod_1.z.array(zod_1.z.string()).optional().describe('Updated tags'),
+export const artifactUpdateInputSchema = z.object({
+    id: z.string().min(1).describe('Artifact UUID to update'),
+    title: z.string().optional().describe('New title (omit to preserve the current title)'),
+    content: z.string().optional().describe('New content body'),
+    tags: z.array(z.string()).optional().describe('Updated tags'),
 });
-exports.ARTIFACT_UPDATE_TOOL_DEF = {
+export const ARTIFACT_UPDATE_TOOL_DEF = {
     name: 'tacit_artifact_update',
-    description: 'Update a career artifact by id. Route: PATCH /api/v1/artifacts/:id.',
+    description: 'Update a career artifact by id. Route: PATCH /api/v1/artifacts/:id. ' +
+        'Publishing is not possible through this tool; use tacit_artifact_publish (PATCH status=published returns 422).',
     inputSchema: {
         type: 'object',
         properties: {
             id: { type: 'string', description: 'Artifact UUID to update' },
-            title: { type: 'string', description: 'New title' },
+            title: { type: 'string', description: 'New title (omit to preserve the current title)' },
             content: { type: 'string', description: 'New content body' },
             tags: { type: 'array', items: { type: 'string' }, description: 'Updated tags' },
         },
         required: ['id'],
     },
 };
-function buildArtifactUpdateRequest(client, input) {
+export function buildArtifactUpdateRequest(client, input) {
     return {
         async execute() {
             const { id, title, content, tags } = input;
@@ -184,18 +193,18 @@ function buildArtifactUpdateRequest(client, input) {
         },
     };
 }
-async function handleArtifactUpdate(args) {
-    const parsed = exports.artifactUpdateInputSchema.safeParse(args);
+export async function handleArtifactUpdate(args) {
+    const parsed = artifactUpdateInputSchema.safeParse(args);
     if (!parsed.success) {
         return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
     }
-    return buildArtifactUpdateRequest((0, client_js_1.getClient)(), parsed.data).execute();
+    return buildArtifactUpdateRequest(getClient(), parsed.data).execute();
 }
 // ─── Publish ─────────────────────────────────────────────────────────────────
-exports.artifactPublishInputSchema = zod_1.z.object({
-    id: zod_1.z.string().min(1).describe('Artifact UUID to publish'),
+export const artifactPublishInputSchema = z.object({
+    id: z.string().min(1).describe('Artifact UUID to publish'),
 });
-exports.ARTIFACT_PUBLISH_TOOL_DEF = {
+export const ARTIFACT_PUBLISH_TOOL_DEF = {
     name: 'tacit_artifact_publish',
     description: 'Publish an artifact by id. Route: POST /api/v1/artifacts/:id/publish.',
     inputSchema: {
@@ -206,7 +215,7 @@ exports.ARTIFACT_PUBLISH_TOOL_DEF = {
         required: ['id'],
     },
 };
-function buildArtifactPublishRequest(client, input) {
+export function buildArtifactPublishRequest(client, input) {
     return {
         async execute() {
             const { id } = input;
@@ -221,21 +230,303 @@ function buildArtifactPublishRequest(client, input) {
         },
     };
 }
-async function handleArtifactPublish(args) {
-    const parsed = exports.artifactPublishInputSchema.safeParse(args);
+export async function handleArtifactPublish(args) {
+    const parsed = artifactPublishInputSchema.safeParse(args);
     if (!parsed.success) {
         return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
     }
-    return buildArtifactPublishRequest((0, client_js_1.getClient)(), parsed.data).execute();
-}
-// ─── Shared error helper ──────────────────────────────────────────────────────
-function apiErrorResult(err, endpoint) {
-    if (err instanceof client_js_1.TacitApiError) {
-        return {
-            content: [{ type: 'text', text: `API error ${err.statusCode} on ${endpoint}: ${err.body}` }],
-            isError: true,
-        };
+    return buildArtifactPublishRequest(getClient(), parsed.data).execute();
+}
+// ─── Get (editor payload) ──────────────────────────────────────────────────────
+export const artifactGetInputSchema = z.object({
+    id: z.string().min(1).describe('Artifact UUID'),
+});
+export const ARTIFACT_GET_TOOL_DEF = {
+    name: 'tacit_artifact_get',
+    description: 'Fetch the editor payload for a single artifact by id (content = COALESCE(NULLIF(raw_content,\'\'), content_body), ' +
+        'title, status, version, …). Workspace-scoped; 404 across tenants. Route: GET /api/v1/artifacts/editor/:id.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Artifact UUID' },
+        },
+        required: ['id'],
+    },
+};
+export function buildArtifactGetRequest(client, input) {
+    return {
+        async execute() {
+            const { id } = input;
+            try {
+                // GET /api/v1/artifacts/editor/:id
+                const result = await client.get(`/api/v1/artifacts/editor/${id}`);
+                const url = client.webUrl('artifact', id);
+                const enriched = url ? { ...result, web_url: url } : result;
+                return { content: [{ type: 'text', text: JSON.stringify(enriched) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, '/api/v1/artifacts/editor/:id');
+            }
+        },
+    };
+}
+export async function handleArtifactGet(args) {
+    const parsed = artifactGetInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
     }
-    const msg = err instanceof Error ? err.message : String(err);
-    return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+    return buildArtifactGetRequest(getClient(), parsed.data).execute();
+}
+// ─── Revise ──────────────────────────────────────────────────────────────────
+export const artifactReviseInputSchema = z.object({
+    id: z.string().min(1).describe('UUID of the PUBLISHED artifact to revise'),
+    title: z.string().optional().describe('New title (omit to preserve the original title; the version sidebar tracks origin)'),
+    if_match: z.string().optional().describe('RFC3339 updated_at of the parent (optional concurrency guard)'),
+});
+export const ARTIFACT_REVISE_TOOL_DEF = {
+    name: 'tacit_artifact_revise',
+    description: 'Create a new revision of a PUBLISHED artifact (must be the chain tail). ' +
+        '409 not_chain_tail if a newer revision already exists; 412 stale_artifact if if_match does not match. ' +
+        'Route: POST /api/v1/artifacts/:id/revise.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'UUID of the PUBLISHED artifact to revise' },
+            title: { type: 'string', description: 'New title (omit to preserve the original)' },
+            if_match: { type: 'string', description: 'RFC3339 updated_at of the parent (optional concurrency guard)' },
+        },
+        required: ['id'],
+    },
+};
+export function buildArtifactReviseRequest(client, input) {
+    return {
+        async execute() {
+            const { id, title, if_match } = input;
+            try {
+                const body = {};
+                if (title !== undefined)
+                    body['title'] = title;
+                // POST /api/v1/artifacts/:id/revise — if_match forwarded as the If-Match header, not the body.
+                const result = await client.post(`/api/v1/artifacts/${id}/revise`, body, if_match !== undefined ? { 'If-Match': if_match } : undefined);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, '/api/v1/artifacts/:id/revise');
+            }
+        },
+    };
+}
+export async function handleArtifactRevise(args) {
+    const parsed = artifactReviseInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildArtifactReviseRequest(getClient(), parsed.data).execute();
+}
+// ─── Versions ────────────────────────────────────────────────────────────────
+export const artifactVersionsInputSchema = z.object({
+    id: z.string().min(1).describe('Artifact UUID (any member of the revision chain)'),
+});
+export const ARTIFACT_VERSIONS_TOOL_DEF = {
+    name: 'tacit_artifact_versions',
+    description: 'List the revision chain for an artifact. Route: GET /api/v1/artifacts/:id/versions.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Artifact UUID' },
+        },
+        required: ['id'],
+    },
+};
+export function buildArtifactVersionsRequest(client, input) {
+    return {
+        async execute() {
+            const { id } = input;
+            try {
+                // GET /api/v1/artifacts/:id/versions
+                const result = await client.get(`/api/v1/artifacts/${id}/versions`);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, '/api/v1/artifacts/:id/versions');
+            }
+        },
+    };
+}
+export async function handleArtifactVersions(args) {
+    const parsed = artifactVersionsInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildArtifactVersionsRequest(getClient(), parsed.data).execute();
+}
+// ─── Delete ─────────────────────────────────────────────────────────────────
+export const artifactDeleteInputSchema = z.object({
+    id: z.string().uuid().describe('Artifact UUID to delete'),
+    confirm: z.boolean().describe('Must be true to execute the delete — safety guard against accidental deletion'),
+    force: z.boolean().optional().describe('Set true to delete a PUBLISHED artifact. Requires MENTAT or TWIN autonomy.'),
+});
+export const ARTIFACT_DELETE_TOOL_DEF = {
+    name: 'tacit_artifact_delete',
+    description: 'Soft-delete an artifact by id (sets deleted_at, cascades search_projections cleanup). ' +
+        'DRAFT / UNDER_REVIEW artifacts delete normally. PUBLISHED artifacts require force=true ' +
+        'and MENTAT or TWIN autonomy. confirm must be true. Route: DELETE /api/v1/artifacts/editor/:id.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Artifact UUID to delete' },
+            confirm: { type: 'boolean', description: 'Must be true to execute — safety guard' },
+            force: { type: 'boolean', description: 'Set true to delete a PUBLISHED artifact (requires MENTAT/TWIN autonomy)' },
+        },
+        required: ['id', 'confirm'],
+    },
+};
+export function buildArtifactDeleteRequest(client, input) {
+    return {
+        async execute() {
+            const { id, confirm, force } = input;
+            if (!confirm) {
+                return {
+                    content: [{ type: 'text', text: 'Delete aborted: confirm must be true.' }],
+                    isError: true,
+                };
+            }
+            try {
+                const qs = force ? '?force=true' : '';
+                const result = await client.delete(`/api/v1/artifacts/editor/${id}${qs}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result ?? { artifact_id: id, deleted: true }) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, '/api/v1/artifacts/editor/:id');
+            }
+        },
+    };
+}
+export async function handleArtifactDelete(args) {
+    const parsed = artifactDeleteInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildArtifactDeleteRequest(getClient(), parsed.data).execute();
+}
+export function registerArtifactTools(server, getClientFn) {
+    server.tool('tacit_artifact_list', 'List/search artifacts from the Tacit workspace. Route: GET /api/v1/artifacts.', {
+        q: z.string().optional().describe('Full-text search over title and body'),
+        origin: z.enum(['IMPORTED', 'SYNTHESIZED', 'WIKI_CONVERGENCE']).optional().describe('Filter by artifact origin'),
+        status: z.string().optional().describe('Comma-separated status filter'),
+        portfolio_id: z.string().optional().describe('Filter by portfolio UUID'),
+        limit: z.number().int().positive().optional().describe('Maximum artifacts to return'),
+        offset: z.number().int().nonnegative().optional().describe('Pagination offset'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildArtifactListRequest(client, args).execute();
+    });
+    server.tool('tacit_artifact_create', 'Create an artifact. Route: POST /api/v1/artifacts.', {
+        title: z.string().min(1).describe('Artifact title'),
+        domain: z.string().optional().describe('Domain tag (e.g. CAREER, GENERAL, ENGINEERING, PRODUCT). Defaults to GENERAL.'),
+        portfolio_id: z.string().min(1).describe('Portfolio UUID (REQUIRED)'),
+        structured_metadata: z.record(z.unknown()).optional().describe('Structured metadata'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildArtifactCreateRequest(client, args).execute();
+    });
+    server.tool('tacit_artifact_update', 'Update an artifact by id. Route: PATCH /api/v1/artifacts/:id.', {
+        id: z.string().min(1).describe('Artifact UUID to update'),
+        title: z.string().optional().describe('New title'),
+        content: z.string().optional().describe('New content body'),
+        tags: z.array(z.string()).optional().describe('Updated tags'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildArtifactUpdateRequest(client, args).execute();
+    });
+    server.tool('tacit_artifact_publish', 'Publish an artifact by id. Route: POST /api/v1/artifacts/:id/publish.', {
+        id: z.string().min(1).describe('Artifact UUID to publish'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildArtifactPublishRequest(client, args).execute();
+    });
+    server.tool('tacit_artifact_get', 'Fetch editor payload for a single artifact. Route: GET /api/v1/artifacts/editor/:id.', {
+        id: z.string().min(1).describe('Artifact UUID'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildArtifactGetRequest(client, args).execute();
+    });
+    server.tool('tacit_artifact_revise', 'Create a new revision of a PUBLISHED artifact. Route: POST /api/v1/artifacts/:id/revise.', {
+        id: z.string().min(1).describe('UUID of the PUBLISHED artifact to revise'),
+        title: z.string().optional().describe('New title'),
+        if_match: z.string().optional().describe('RFC3339 updated_at concurrency guard'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildArtifactReviseRequest(client, args).execute();
+    });
+    server.tool('tacit_artifact_versions', 'List the revision chain for an artifact. Route: GET /api/v1/artifacts/:id/versions.', {
+        id: z.string().min(1).describe('Artifact UUID'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildArtifactVersionsRequest(client, args).execute();
+    });
+    server.tool('tacit_artifact_delete', 'Soft-delete an artifact. DRAFT/UNDER_REVIEW delete normally. PUBLISHED requires force=true and MENTAT/TWIN autonomy. Route: DELETE /api/v1/artifacts/editor/:id.', {
+        id: z.string().uuid().describe('Artifact UUID to delete'),
+        confirm: z.boolean().describe('Must be true to execute — safety guard'),
+        force: z.boolean().optional().describe('Set true to delete a PUBLISHED artifact (requires MENTAT/TWIN autonomy)'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildArtifactDeleteRequest(client, args).execute();
+    });
+    server.tool('tacit_artifact_pdf', 'Export an artifact as PDF.', {
+        artifact_id: z.string().uuid().describe('Artifact UUID'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.post(`/api/v1/artifacts/${args.artifact_id}/pdf`, {});
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return apiErrorResult(err, `/api/v1/artifacts/${args.artifact_id}/pdf`);
+        }
+    });
+    server.tool('tacit_artifact_html_token', 'Generate a token for authenticated HTML viewing of an artifact.', {
+        artifact_id: z.string().uuid().describe('Artifact UUID'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.post(`/api/v1/artifacts/${args.artifact_id}/html-token`, {});
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return apiErrorResult(err, `/api/v1/artifacts/${args.artifact_id}/html-token`);
+        }
+    });
+    server.tool('tacit_import_artifact', 'Import an artifact from external content into a portfolio/program.', {
+        portfolio_id: z.string().uuid().describe('Target portfolio UUID'),
+        program_id: z.string().uuid().describe('Target program UUID'),
+        title: z.string().describe('Artifact title'),
+        content: z.string().describe('Artifact content body'),
+        output_format: z.string().describe('Output format'),
+        domain: z.string().describe('Domain: research, engineering, design, etc.'),
+        source_event_id: z.string().uuid().optional().describe('Originating event UUID'),
+        source_type: z.string().optional().describe('Source type (OBSIDIAN_GRAPH triggers vault pre-processing)'),
+        filename: z.string().optional().describe('Original filename (required when source_type=OBSIDIAN_GRAPH)'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.post('/api/v1/artifacts/import', args);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return apiErrorResult(err, '/api/v1/artifacts/import');
+        }
+    });
+    server.tool('tacit_share_artifact', 'Generate a share token URL for external access to an artifact.', {
+        artifact_id: z.string().uuid().describe('Artifact UUID'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.post(`/api/v1/artifacts/${args.artifact_id}/share-token`, {});
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return apiErrorResult(err, `/api/v1/artifacts/${args.artifact_id}/share-token`);
+        }
+    });
 }

package/dist/tools/chronicle.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { TacitClient } from '../client.js';
+export declare function registerChronicleTools(server: McpServer, getClient: () => Promise<TacitClient>): void;