@tacitai/mcp-server 0.1.1 → 0.3.0

package/dist/tools/pyramid.js

@@ -0,0 +1,758 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Pyramid tools — CLI wrappers for portfolio, program, dossier, and
+ * value-stream CRUD on the Axum REST API.
+ *
+ * Routes (Axum, all under /api/v1):
+ *   GET/POST   /portfolios
+ *   GET/POST   /portfolios/:id/programs
+ *   GET/POST   /dossiers
+ *   GET/PUT/DELETE /dossiers/:id
+ *   GET/POST   /alignment/value-streams
+ */
+import { z } from 'zod';
+import { getClient, TacitApiError, TokenExpiredError } from '../client.js';
+import { apiErrorResult as sharedApiErrorResult } from './errors.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_pyramid_list_portfolios ──────────────────────────────────────────
+export const listPortfoliosInputSchema = z.object({});
+export const LIST_PORTFOLIOS_TOOL_DEF = {
+    name: 'tacit_pyramid_list_portfolios',
+    description: 'List all portfolios in the workspace with artifact counts.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+};
+export function buildListPortfoliosRequest(client, _input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get('/api/v1/portfolios');
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_list_portfolios');
+            }
+        },
+    };
+}
+export async function handleListPortfolios(args) {
+    const parsed = listPortfoliosInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildListPortfoliosRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_pyramid_create_portfolio ─────────────────────────────────────────
+export const createPortfolioInputSchema = z.object({
+    name: z.string().min(1).describe('Portfolio name'),
+    pillar: z.enum(['INTERNAL', 'PRODUCT', 'BUSINESS']).describe('Pillar: INTERNAL, PRODUCT, or BUSINESS'),
+    domain_schema_id: z.string().optional().describe('Optional domain schema ID'),
+});
+export const CREATE_PORTFOLIO_TOOL_DEF = {
+    name: 'tacit_pyramid_create_portfolio',
+    description: 'Create a new portfolio in the workspace. Pillar must be INTERNAL, PRODUCT, or BUSINESS.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Portfolio name' },
+            pillar: { type: 'string', enum: ['INTERNAL', 'PRODUCT', 'BUSINESS'], description: 'Pillar' },
+            domain_schema_id: { type: 'string', description: 'Optional domain schema ID' },
+        },
+        required: ['name', 'pillar'],
+    },
+};
+export function buildCreatePortfolioRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { name: input.name, pillar: input.pillar };
+                if (input.domain_schema_id)
+                    body['domain_schema_id'] = input.domain_schema_id;
+                const result = await client.post('/api/v1/portfolios', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_create_portfolio');
+            }
+        },
+    };
+}
+export async function handleCreatePortfolio(args) {
+    const parsed = createPortfolioInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildCreatePortfolioRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_pyramid_list_programs ────────────────────────────────────────────
+export const listProgramsInputSchema = z.object({
+    portfolio_id: z.string().min(1).describe('UUID of the portfolio'),
+});
+export const LIST_PROGRAMS_TOOL_DEF = {
+    name: 'tacit_pyramid_list_programs',
+    description: 'List programs within a portfolio, with artifact counts.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            portfolio_id: { type: 'string', description: 'UUID of the portfolio' },
+        },
+        required: ['portfolio_id'],
+    },
+};
+export function buildListProgramsRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get(`/api/v1/portfolios/${input.portfolio_id}/programs`);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_list_programs');
+            }
+        },
+    };
+}
+export async function handleListPrograms(args) {
+    const parsed = listProgramsInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildListProgramsRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_pyramid_create_program ───────────────────────────────────────────
+export const createProgramInputSchema = z.object({
+    portfolio_id: z.string().min(1).describe('UUID of the parent portfolio'),
+    name: z.string().min(1).describe('Program name'),
+    domain: z.string().optional().describe('Domain tag (e.g. ENGINEERING, DESIGN, MARKETING)'),
+    description: z.string().optional().describe('Program description'),
+    value_stream_id: z.string().optional().describe('Optional UUID of the value stream to assign this program to'),
+    weight: z.number().int().optional().describe('Sort weight (default 1)'),
+    target_starts_at: z.string().optional().describe('ISO 8601 start date'),
+    target_ends_at: z.string().optional().describe('ISO 8601 end date'),
+});
+export const CREATE_PROGRAM_TOOL_DEF = {
+    name: 'tacit_pyramid_create_program',
+    description: 'Create a new program within a portfolio. Optionally set domain, description, dates, and weight. Optionally assign to a value stream via value_stream_id.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            portfolio_id: { type: 'string', description: 'UUID of the parent portfolio' },
+            name: { type: 'string', description: 'Program name' },
+            domain: { type: 'string', description: 'Domain tag (e.g. ENGINEERING, DESIGN)' },
+            description: { type: 'string', description: 'Program description' },
+            value_stream_id: { type: 'string', description: 'Optional UUID of the value stream to assign this program to' },
+            weight: { type: 'number', description: 'Sort weight (default 1)' },
+            target_starts_at: { type: 'string', description: 'ISO 8601 start date' },
+            target_ends_at: { type: 'string', description: 'ISO 8601 end date' },
+        },
+        required: ['portfolio_id', 'name'],
+    },
+};
+export function buildCreateProgramRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { name: input.name };
+                if (input.domain)
+                    body['domain'] = input.domain;
+                if (input.description)
+                    body['description'] = input.description;
+                if (input.weight !== undefined)
+                    body['weight'] = input.weight;
+                if (input.value_stream_id)
+                    body['value_stream_id'] = input.value_stream_id;
+                if (input.target_starts_at)
+                    body['target_starts_at'] = input.target_starts_at;
+                if (input.target_ends_at)
+                    body['target_ends_at'] = input.target_ends_at;
+                const result = await client.post(`/api/v1/portfolios/${input.portfolio_id}/programs`, body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_create_program');
+            }
+        },
+    };
+}
+export async function handleCreateProgram(args) {
+    const parsed = createProgramInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildCreateProgramRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_pyramid_list_dossiers ────────────────────────────────────────────
+export const listDossiersInputSchema = z.object({});
+export const LIST_DOSSIERS_TOOL_DEF = {
+    name: 'tacit_pyramid_list_dossiers',
+    description: 'List dossiers in the workspace. Returns name, document count, portfolio/program placement, and staleness info.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+};
+export function buildListDossiersRequest(client, _input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get('/api/v1/dossiers');
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_list_dossiers');
+            }
+        },
+    };
+}
+export async function handleListDossiers(args) {
+    const parsed = listDossiersInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildListDossiersRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_pyramid_get_dossier ──────────────────────────────────────────────
+export const getDossierInputSchema = z.object({
+    dossier_id: z.string().min(1).describe('UUID of the dossier'),
+});
+export const GET_DOSSIER_TOOL_DEF = {
+    name: 'tacit_pyramid_get_dossier',
+    description: 'Get a single dossier by ID, including its document list and stale document IDs.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            dossier_id: { type: 'string', description: 'UUID of the dossier' },
+        },
+        required: ['dossier_id'],
+    },
+};
+export function buildGetDossierRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get(`/api/v1/dossiers/${input.dossier_id}`);
+                const url = client.webUrl('dossier_summary', input.dossier_id);
+                const enriched = url ? { ...result, web_url: url } : result;
+                return { content: [{ type: 'text', text: JSON.stringify(enriched) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_get_dossier');
+            }
+        },
+    };
+}
+export async function handleGetDossier(args) {
+    const parsed = getDossierInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildGetDossierRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_pyramid_create_dossier ───────────────────────────────────────────
+export const createDossierInputSchema = z.object({
+    name: z.string().min(1).describe('Dossier name'),
+    document_ids: z.array(z.string()).optional().describe('UUIDs of published artifacts to include'),
+    portfolio_id: z.string().optional().describe('UUID of the portfolio to place this dossier in'),
+    program_id: z.string().optional().describe('UUID of the program to place this dossier in'),
+    dossier_kind: z.string().optional().describe('Kind: SCOPING_SESSION (default) or PROJECT_DOSSIER'),
+    status: z.string().optional().describe('Status (default ACTIVE)'),
+    weight: z.number().int().optional().describe('Sort weight (default 1)'),
+    target_starts_at: z.string().optional().describe('ISO 8601 start date'),
+    target_ends_at: z.string().optional().describe('ISO 8601 end date'),
+});
+export const CREATE_DOSSIER_TOOL_DEF = {
+    name: 'tacit_pyramid_create_dossier',
+    description: 'Create a new dossier. Optionally place it in a portfolio/program and include document IDs.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Dossier name' },
+            document_ids: { type: 'array', items: { type: 'string' }, description: 'Artifact UUIDs to include' },
+            portfolio_id: { type: 'string', description: 'Portfolio UUID' },
+            program_id: { type: 'string', description: 'Program UUID' },
+            dossier_kind: { type: 'string', description: 'SCOPING_SESSION or PROJECT_DOSSIER' },
+            status: { type: 'string', description: 'Status (default ACTIVE)' },
+            weight: { type: 'number', description: 'Sort weight' },
+            target_starts_at: { type: 'string', description: 'ISO 8601 start date' },
+            target_ends_at: { type: 'string', description: 'ISO 8601 end date' },
+        },
+        required: ['name'],
+    },
+};
+export function buildCreateDossierRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { name: input.name };
+                if (input.document_ids)
+                    body['document_ids'] = input.document_ids;
+                if (input.portfolio_id)
+                    body['portfolio_id'] = input.portfolio_id;
+                if (input.program_id)
+                    body['program_id'] = input.program_id;
+                if (input.dossier_kind)
+                    body['dossier_kind'] = input.dossier_kind;
+                if (input.status)
+                    body['status'] = input.status;
+                if (input.weight !== undefined)
+                    body['weight'] = input.weight;
+                if (input.target_starts_at)
+                    body['target_starts_at'] = input.target_starts_at;
+                if (input.target_ends_at)
+                    body['target_ends_at'] = input.target_ends_at;
+                const result = await client.post('/api/v1/dossiers', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_create_dossier');
+            }
+        },
+    };
+}
+export async function handleCreateDossier(args) {
+    const parsed = createDossierInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildCreateDossierRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_pyramid_update_dossier ───────────────────────────────────────────
+export const updateDossierInputSchema = z.object({
+    dossier_id: z.string().min(1).describe('UUID of the dossier to update'),
+    name: z.string().optional().describe('Updated dossier name (keeps current if omitted)'),
+    document_ids: z.array(z.string()).optional().describe('Updated document ID list (keeps current if omitted)'),
+    portfolio_id: z.string().optional().describe('Portfolio UUID (keeps current if omitted)'),
+    program_id: z.string().optional().describe('Program UUID (keeps current if omitted)'),
+    status: z.string().optional().describe('Status (keeps current if omitted)'),
+    weight: z.number().int().optional().describe('Sort weight (keeps current if omitted)'),
+    target_starts_at: z.string().nullable().optional().describe('ISO 8601 start date (null to clear, omit to keep)'),
+    target_ends_at: z.string().nullable().optional().describe('ISO 8601 end date (null to clear, omit to keep)'),
+});
+export const UPDATE_DOSSIER_TOOL_DEF = {
+    name: 'tacit_pyramid_update_dossier',
+    description: 'Update an existing dossier. Only supply the fields you want to change — omitted fields keep their current values. ' +
+        'The backend is a full-replace PUT, so this tool fetches the current state first and merges your changes.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            dossier_id: { type: 'string', description: 'UUID of the dossier' },
+            name: { type: 'string', description: 'Updated name' },
+            document_ids: { type: 'array', items: { type: 'string' }, description: 'Updated document IDs' },
+            portfolio_id: { type: 'string', description: 'Portfolio UUID' },
+            program_id: { type: 'string', description: 'Program UUID' },
+            status: { type: 'string', description: 'Status' },
+            weight: { type: 'number', description: 'Sort weight' },
+            target_starts_at: { type: ['string', 'null'], description: 'ISO 8601 start date (null to clear)' },
+            target_ends_at: { type: ['string', 'null'], description: 'ISO 8601 end date (null to clear)' },
+        },
+        required: ['dossier_id'],
+    },
+};
+export function buildUpdateDossierRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                // Fetch current state — the backend PUT is full-replace, so we must
+                // merge caller-supplied fields onto the existing dossier to avoid
+                // silently wiping omitted fields (document_ids, status, weight, dates).
+                const current = await client.get(`/api/v1/dossiers/${input.dossier_id}`);
+                const body = {
+                    name: input.name ?? current['name'],
+                    document_ids: input.document_ids ?? current['document_ids'] ?? [],
+                    portfolio_id: input.portfolio_id !== undefined ? input.portfolio_id : current['portfolio_id'],
+                    program_id: input.program_id !== undefined ? input.program_id : current['program_id'],
+                    status: input.status ?? current['status'] ?? 'ACTIVE',
+                    weight: input.weight ?? current['weight'] ?? 1,
+                };
+                // Dates: explicit null clears, undefined keeps current
+                body['target_starts_at'] = input.target_starts_at !== undefined
+                    ? input.target_starts_at
+                    : current['target_starts_at'] ?? null;
+                body['target_ends_at'] = input.target_ends_at !== undefined
+                    ? input.target_ends_at
+                    : current['target_ends_at'] ?? null;
+                const result = await client.put(`/api/v1/dossiers/${input.dossier_id}`, body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_update_dossier');
+            }
+        },
+    };
+}
+export async function handleUpdateDossier(args) {
+    const parsed = updateDossierInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildUpdateDossierRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_pyramid_delete_dossier ───────────────────────────────────────────
+export const deleteDossierInputSchema = z.object({
+    dossier_id: z.string().min(1).describe('UUID of the dossier to delete'),
+});
+export const DELETE_DOSSIER_TOOL_DEF = {
+    name: 'tacit_pyramid_delete_dossier',
+    description: 'Permanently delete a dossier. This is irreversible.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            dossier_id: { type: 'string', description: 'UUID of the dossier to delete' },
+        },
+        required: ['dossier_id'],
+    },
+};
+export function buildDeleteDossierRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                await client.delete(`/api/v1/dossiers/${input.dossier_id}`);
+                return { content: [{ type: 'text', text: JSON.stringify({ deleted: true, dossier_id: input.dossier_id }) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_delete_dossier');
+            }
+        },
+    };
+}
+export async function handleDeleteDossier(args) {
+    const parsed = deleteDossierInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildDeleteDossierRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_pyramid_list_value_streams ───────────────────────────────────────
+export const listValueStreamsInputSchema = z.object({});
+export const LIST_VALUE_STREAMS_TOOL_DEF = {
+    name: 'tacit_pyramid_list_value_streams',
+    description: 'List all value streams in the workspace.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+};
+export function buildListValueStreamsRequest(client, _input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get('/api/v1/alignment/value-streams');
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_list_value_streams');
+            }
+        },
+    };
+}
+export async function handleListValueStreams(args) {
+    const parsed = listValueStreamsInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildListValueStreamsRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_pyramid_create_value_stream ──────────────────────────────────────
+export const createValueStreamInputSchema = z.object({
+    portfolio_id: z.string().min(1).describe('UUID of the parent portfolio'),
+    name: z.string().min(1).describe('Value stream name (1–200 chars)'),
+    description: z.string().optional().describe('Optional description'),
+});
+export const CREATE_VALUE_STREAM_TOOL_DEF = {
+    name: 'tacit_pyramid_create_value_stream',
+    description: 'Create a new value stream under a portfolio. Requires MENTAT autonomy level.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            portfolio_id: { type: 'string', description: 'UUID of the parent portfolio' },
+            name: { type: 'string', description: 'Value stream name' },
+            description: { type: 'string', description: 'Optional description' },
+        },
+        required: ['portfolio_id', 'name'],
+    },
+};
+export function buildCreateValueStreamRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { portfolio_id: input.portfolio_id, name: input.name };
+                if (input.description)
+                    body['description'] = input.description;
+                const result = await client.post('/api/v1/alignment/value-streams', body);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_create_value_stream');
+            }
+        },
+    };
+}
+export async function handleCreateValueStream(args) {
+    const parsed = createValueStreamInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildCreateValueStreamRequest(getClient(), parsed.data).execute();
+}
+// ─── tacit_pyramid_assign_program_to_value_stream ─────────────────────────
+export const assignProgramToVSInputSchema = z.object({
+    value_stream_id: z.string().min(1).describe('UUID of the value stream'),
+    program_id: z.string().min(1).describe('UUID of the program to assign'),
+});
+export const ASSIGN_PROGRAM_TO_VS_TOOL_DEF = {
+    name: 'tacit_pyramid_assign_program_to_value_stream',
+    description: 'Assign an existing program to a value stream. Requires MENTAT autonomy level.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            value_stream_id: { type: 'string', description: 'UUID of the value stream' },
+            program_id: { type: 'string', description: 'UUID of the program to assign' },
+        },
+        required: ['value_stream_id', 'program_id'],
+    },
+};
+export function buildAssignProgramToVSRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const body = { program_id: input.program_id, value_stream_id: input.value_stream_id };
+                await client.patch(`/api/v1/alignment/value-streams/${input.value_stream_id}/programs`, body);
+                return { content: [{ type: 'text', text: JSON.stringify({ assigned: true, program_id: input.program_id, value_stream_id: input.value_stream_id }) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_pyramid_assign_program_to_value_stream');
+            }
+        },
+    };
+}
+export async function handleAssignProgramToVS(args) {
+    const parsed = assignProgramToVSInputSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: 'text', text: `Invalid input: ${parsed.error.message}` }], isError: true };
+    }
+    return buildAssignProgramToVSRequest(getClient(), parsed.data).execute();
+}
+export function registerPyramidTools(server, getClientFn) {
+    server.tool('tacit_pyramid_list_portfolios', 'List all portfolios in the workspace.', {}, async () => {
+        const client = await getClientFn();
+        return buildListPortfoliosRequest(client, {}).execute();
+    });
+    server.tool('tacit_pyramid_create_portfolio', 'Create a new portfolio.', {
+        name: z.string().min(1).describe('Portfolio name'),
+        pillar: z.enum(['INTERNAL', 'PRODUCT', 'BUSINESS']).describe('Pillar'),
+        domain_schema_id: z.string().optional().describe('Optional domain schema ID'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildCreatePortfolioRequest(client, args).execute();
+    });
+    server.tool('tacit_pyramid_list_programs', 'List programs within a portfolio.', {
+        portfolio_id: z.string().min(1).describe('Portfolio UUID'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildListProgramsRequest(client, args).execute();
+    });
+    server.tool('tacit_pyramid_create_program', 'Create a new program within a portfolio.', {
+        portfolio_id: z.string().min(1).describe('Parent portfolio UUID'),
+        name: z.string().min(1).describe('Program name'),
+        domain: z.string().optional().describe('Domain tag'),
+        description: z.string().optional().describe('Description'),
+        value_stream_id: z.string().optional().describe('Value stream UUID'),
+        weight: z.number().int().optional().describe('Sort weight'),
+        target_starts_at: z.string().optional().describe('ISO 8601 start date'),
+        target_ends_at: z.string().optional().describe('ISO 8601 end date'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildCreateProgramRequest(client, args).execute();
+    });
+    server.tool('tacit_pyramid_list_dossiers', 'List dossiers in the workspace.', {}, async () => {
+        const client = await getClientFn();
+        return buildListDossiersRequest(client, {}).execute();
+    });
+    server.tool('tacit_pyramid_get_dossier', 'Get a single dossier by ID.', {
+        dossier_id: z.string().min(1).describe('Dossier UUID'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildGetDossierRequest(client, args).execute();
+    });
+    server.tool('tacit_pyramid_create_dossier', 'Create a new dossier.', {
+        name: z.string().min(1).describe('Dossier name'),
+        document_ids: z.array(z.string()).optional().describe('Artifact UUIDs to include'),
+        portfolio_id: z.string().optional().describe('Portfolio UUID'),
+        program_id: z.string().optional().describe('Program UUID'),
+        dossier_kind: z.string().optional().describe('SCOPING_SESSION or PROJECT_DOSSIER'),
+        status: z.string().optional().describe('Status'),
+        weight: z.number().int().optional().describe('Sort weight'),
+        target_starts_at: z.string().optional().describe('ISO 8601 start date'),
+        target_ends_at: z.string().optional().describe('ISO 8601 end date'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildCreateDossierRequest(client, args).execute();
+    });
+    server.tool('tacit_pyramid_update_dossier', 'Update an existing dossier (fetch-then-merge PUT).', {
+        dossier_id: z.string().min(1).describe('Dossier UUID'),
+        name: z.string().optional().describe('Updated name'),
+        document_ids: z.array(z.string()).optional().describe('Updated document IDs'),
+        portfolio_id: z.string().optional().describe('Portfolio UUID'),
+        program_id: z.string().optional().describe('Program UUID'),
+        status: z.string().optional().describe('Status'),
+        weight: z.number().int().optional().describe('Sort weight'),
+        target_starts_at: z.string().nullable().optional().describe('Start date (null to clear)'),
+        target_ends_at: z.string().nullable().optional().describe('End date (null to clear)'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildUpdateDossierRequest(client, args).execute();
+    });
+    server.tool('tacit_pyramid_delete_dossier', 'Permanently delete a dossier.', {
+        dossier_id: z.string().min(1).describe('Dossier UUID'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildDeleteDossierRequest(client, args).execute();
+    });
+    server.tool('tacit_pyramid_list_value_streams', 'List all value streams in the workspace.', {}, async () => {
+        const client = await getClientFn();
+        return buildListValueStreamsRequest(client, {}).execute();
+    });
+    server.tool('tacit_pyramid_create_value_stream', 'Create a new value stream under a portfolio.', {
+        portfolio_id: z.string().min(1).describe('Parent portfolio UUID'),
+        name: z.string().min(1).describe('Value stream name'),
+        description: z.string().optional().describe('Description'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildCreateValueStreamRequest(client, args).execute();
+    });
+    server.tool('tacit_pyramid_assign_program_to_value_stream', 'Assign a program to a value stream.', {
+        value_stream_id: z.string().min(1).describe('Value stream UUID'),
+        program_id: z.string().min(1).describe('Program UUID'),
+    }, async (args) => {
+        const client = await getClientFn();
+        return buildAssignProgramToVSRequest(client, args).execute();
+    });
+    server.tool('tacit_patch_portfolio', "Update a portfolio's name or pillar.", {
+        portfolio_id: z.string().uuid().describe('Portfolio UUID'),
+        name: z.string().optional().describe('New name'),
+        pillar: z.string().optional().describe('New pillar'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const { portfolio_id, ...body } = args;
+            const data = await client.patch(`/api/v1/portfolios/${portfolio_id}`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return sharedApiErrorResult(err, '/api/v1/portfolios');
+        }
+    });
+    server.tool('tacit_delete_portfolio', 'Delete a portfolio.', {
+        portfolio_id: z.string().uuid().describe('Portfolio UUID to delete'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.delete(`/api/v1/portfolios/${args.portfolio_id}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return sharedApiErrorResult(err, '/api/v1/portfolios');
+        }
+    });
+    server.tool('tacit_patch_program', "Update a program's fields.", {
+        portfolio_id: z.string().uuid().describe('Portfolio UUID'),
+        program_id: z.string().uuid().describe('Program UUID'),
+        name: z.string().optional().describe('New name'),
+        description: z.string().optional().describe('New description'),
+        weight: z.number().int().optional().describe('New sort weight'),
+        target_starts_at: z.string().datetime().nullable().optional().describe('ISO 8601 start date'),
+        target_ends_at: z.string().datetime().nullable().optional().describe('ISO 8601 end date'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const { portfolio_id, program_id, ...body } = args;
+            const data = await client.patch(`/api/v1/portfolios/${portfolio_id}/programs/${program_id}`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return sharedApiErrorResult(err, '/api/v1/portfolios/programs');
+        }
+    });
+    server.tool('tacit_delete_program', 'Delete a program.', {
+        portfolio_id: z.string().uuid().describe('Portfolio UUID'),
+        program_id: z.string().uuid().describe('Program UUID to delete'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.delete(`/api/v1/portfolios/${args.portfolio_id}/programs/${args.program_id}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return sharedApiErrorResult(err, '/api/v1/portfolios/programs');
+        }
+    });
+    server.tool('tacit_portfolio_artifacts', 'List artifacts within a portfolio.', {
+        portfolio_id: z.string().uuid().describe('Portfolio UUID'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.get(`/api/v1/portfolios/${args.portfolio_id}/artifacts`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return sharedApiErrorResult(err, '/api/v1/portfolios/artifacts');
+        }
+    });
+    server.tool('tacit_get_value_stream', 'Get a value stream by ID.', {
+        value_stream_id: z.string().uuid().describe('Value stream UUID'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.get(`/api/v1/alignment/value-streams/${args.value_stream_id}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return sharedApiErrorResult(err, '/api/v1/alignment/value-streams');
+        }
+    });
+    server.tool('tacit_patch_value_stream', "Update a value stream's name, description, or status.", {
+        value_stream_id: z.string().uuid().describe('Value stream UUID'),
+        name: z.string().optional().describe('New name'),
+        description: z.string().optional().describe('New description'),
+        status: z.string().optional().describe('New status'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const { value_stream_id, ...body } = args;
+            const data = await client.patch(`/api/v1/alignment/value-streams/${value_stream_id}`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return sharedApiErrorResult(err, '/api/v1/alignment/value-streams');
+        }
+    });
+    server.tool('tacit_delete_value_stream', 'Delete a value stream.', {
+        value_stream_id: z.string().uuid().describe('Value stream UUID to delete'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const data = await client.delete(`/api/v1/alignment/value-streams/${args.value_stream_id}`);
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            return sharedApiErrorResult(err, '/api/v1/alignment/value-streams');
+        }
+    });
+}