@tacitai/mcp-server 0.3.2 → 0.5.0

package/dist/index.js

@@ -48,6 +48,7 @@ import { registerPyramidTools } from './tools/pyramid.js';
 import { registerSharingTools } from './tools/sharing.js';
 import { registerKbTools } from './tools/kb.js';
 import { registerLakeTools } from './tools/lake.js';
+import { registerGithubTools } from './tools/github.js';
 import { registerWebUrlTools } from './tools/web-url.js';
 import { registerWorkspaceTools } from './tools/workspaces.js';
 import { registerChronicleTools } from './tools/chronicle.js';
@@ -57,6 +58,8 @@ import { registerLakeStructureTools } from './tools/lake-structure.js';
 import { registerResearchTools } from './tools/research.js';
 import { registerGmTools } from './tools/gm.js';
 import { registerSkillTools } from './tools/skills.js';
+import { registerWikiTools } from './tools/wiki.js';
+import { registerVoiceTools } from './tools/voice.js';
 import { registerPrompts } from './prompts.js';
 import { getRequestPrincipal } from './client.js';
 // Setup wizard (MV-1057h / W5)
@@ -169,6 +172,7 @@ async function run() {
     registerSharingTools(server, getClient);
     registerKbTools(server, getClient);
     registerLakeTools(server, getClient);
+    registerGithubTools(server, getClient);
     registerWebUrlTools(server);
     registerWorkspaceTools(server, getClient);
     registerChronicleTools(server, getClient);
@@ -178,7 +182,9 @@ async function run() {
     registerGmTools(server, getClient);
     registerResearchTools(server, getClient, getRequestPrincipal);
     registerSkillTools(server, getClient);
-    registerPrompts(server);
+    registerWikiTools(server, getClient);
+    registerVoiceTools(server, getClient);
+    registerPrompts(server, getClient);
     if (process.env['MCP_TRANSPORT'] === 'http') {
         await startHttpTransport(server);
         return;

package/dist/prompts.d.ts

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

package/dist/prompts.js

@@ -1,12 +1,294 @@
 // SPDX-License-Identifier: MIT
 import { z } from 'zod';
-const ASSISTANT_SYSTEM_PROMPT = "You are TACIT's workspace assistant. Answer from the user's workspace through TACIT tools. " +
+const ASSISTANT_SYSTEM_PROMPT_STATIC = "You are TACIT's workspace assistant. Answer from the user's workspace through TACIT tools. " +
     'Prefer a single read tool for direct lookups, synthesis for open questions, and ask before any write or dispatch.';
 function userText(text) {
     return { messages: [{ role: 'user', content: { type: 'text', text } }] };
 }
-export function registerPrompts(server) {
-    server.prompt('assistant_system', 'System prompt for the TACIT workspace assistant.', () => userText(ASSISTANT_SYSTEM_PROMPT));
+function buildAssistantSystemPrompt(state) {
+    const name = state?.name || 'this workspace';
+    const lines = [];
+    lines.push(`You are the workspace assistant for ${name}. You help the team find, organize, and act on their business knowledge through natural language.`);
+    lines.push('');
+    lines.push('## Your personality');
+    lines.push('');
+    lines.push(`- Warm but direct. You know ${name} well and you are here to help.`);
+    lines.push('- Refer to the workspace by name. When citing answers, name the collection or source they came from.');
+    lines.push('- Never list tool names, API endpoints, or technical identifiers. Translate everything into plain language.');
+    lines.push('- Celebrate when something works — say which collection or source an answer came from rather than returning a silent result.');
+    lines.push('');
+    lines.push('## How you work');
+    lines.push('');
+    lines.push('- Questions about the business → search and synthesize from workspace knowledge, always citing sources.');
+    lines.push('- Requests to add content → ingest URLs, files, or text into the workspace.');
+    lines.push('- Organizing work → create collections, portfolios, programs, dossiers — whatever structure the user describes.');
+    lines.push('- Daily operations → morning briefs (with email triage and Slack synthesis when connected), meeting prep, draft replies.');
+    lines.push('- Business workflows → sales proposals, research and publishing, audits, weekly reviews.');
+    lines.push('- Delegation → dispatch crews for complex deliverables; nothing executes without the user\'s approval.');
+    lines.push('');
+    lines.push('## Progressive disclosure');
+    lines.push('');
+    lines.push('Introduce capabilities as they become relevant, not all at once. A user asking their first question does not need to hear about crew delegation. A user building their third report is ready to learn about voice profiles.');
+    lines.push('');
+    lines.push('When suggesting what to try next, frame it around what they just accomplished:');
+    lines.push('- After their first search: "Now that you have seen what is here — want to add something new?"');
+    lines.push('- After ingesting content: "Good — that is in your workspace now. Want to organize it into a collection?"');
+    lines.push('- After connecting tools: "Your Slack and email are flowing in. Try asking for a morning brief."');
+    lines.push('');
+    lines.push('## Safety');
+    lines.push('');
+    lines.push('- Never modify or delete content without explicit approval.');
+    lines.push('- Crew tasks require the user to approve before execution.');
+    lines.push('- When unsure about a destructive action, ask first.');
+    lines.push('');
+    lines.push('## Technical routing');
+    lines.push('');
+    lines.push('Prefer a single read tool for direct lookups, synthesis for open questions, and ask before any write or dispatch.');
+    return lines.join('\n');
+}
+async function fetchWorkspaceState(client) {
+    await client.initialize();
+    const wsName = client.workspaceName || 'your workspace';
+    const [collectionsRes, portfoliosRes, sourcesRes] = await Promise.all([
+        client.get('/api/v1/knowledge/collections').catch(() => []),
+        client.get('/api/v1/portfolios').catch(() => []),
+        client.get('/api/v1/org/lake/sources').catch(() => []),
+    ]);
+    const collections = Array.isArray(collectionsRes)
+        ? collectionsRes
+        : collectionsRes?.collections ?? [];
+    const portfolios = Array.isArray(portfoliosRes)
+        ? portfoliosRes
+        : portfoliosRes?.portfolios ?? [];
+    const sources = Array.isArray(sourcesRes)
+        ? sourcesRes
+        : sourcesRes?.sources ?? [];
+    return {
+        name: wsName,
+        collectionNames: collections.map(c => c.name || c.display_name || '').filter(Boolean).slice(0, 5),
+        collectionCount: collections.length,
+        portfolioNames: portfolios.map(p => p.name || p.display_name || '').filter(Boolean).slice(0, 5),
+        portfolioCount: portfolios.length,
+        sourceCount: sources.length,
+    };
+}
+const CAPABILITY_DOMAINS = [
+    { domain: 'Search & Recall', triggers: ['What do we know about…', 'Find me…', 'Look up…'], description: 'Search workspace knowledge and recall specific items' },
+    { domain: 'Synthesis & Analysis', triggers: ['Summarize…', 'What does our data say about…', 'Compare…'], description: 'Grounded answers with citations from your workspace' },
+    { domain: 'Knowledge Base', triggers: ['Create an article about…', 'Organize our knowledge on…'], description: 'Build and organize your reference library' },
+    { domain: 'Ingestion', triggers: ['Bring in this URL…', 'Add this document…'], description: 'Add content from URLs, files, and repositories' },
+    { domain: 'Business Structure', triggers: ['Show me our portfolios…', 'Create a program for…'], description: 'Organize work into portfolios, programs, and dossiers' },
+    { domain: 'Data Lake', triggers: ['What is in our data lake?', 'Classify this…'], description: 'Raw data storage, classification, and source management' },
+    { domain: 'Voice & Composition', triggers: ['Learn how I write…', 'Draft this in my voice…'], description: 'Learn your writing style and compose in your voice' },
+    { domain: 'Timeline & Chronicle', triggers: ['What happened last week?', 'Show me the timeline…'], description: 'Event timeline and organizational memory' },
+    { domain: 'Agents & Crews', triggers: ['Can someone else do this?', 'Delegate this…'], description: 'Dispatch autonomous agents for complex deliverables' },
+    { domain: 'Documents & Artifacts', triggers: ['Create a report…', 'Draft a document…'], description: 'Create, version, and share structured documents' },
+    { domain: 'Sharing & Outbox', triggers: ['Share this with…', 'Send this to…'], description: 'Queue and send work products externally' },
+    { domain: 'Research', triggers: ['Research this topic…', 'What is the latest on…'], description: 'Deep research with source verification' },
+    { domain: 'Wiki Authoring', triggers: ['Write a wiki article…', 'Validate this for publishing…'], description: 'Author, validate, and publish institutional knowledge' },
+    { domain: 'People & Contacts', triggers: ['Who is…', 'Add a contact for…'], description: 'Manage contacts and organizational relationships' },
+    { domain: 'Daily Operations', triggers: ['Morning brief', 'Triage my email…', 'Prep for my meeting…'], description: 'Daily briefs, email triage, meeting prep, and operational reviews' },
+    { domain: 'Sales', triggers: ['Prepare a proposal for…', 'Run discovery on…'], description: 'End-to-end sales workflows from context brief to pipeline' },
+    { domain: 'Connectors', triggers: ['Connect my Gmail…', 'Add Slack…'], description: 'Connect external tools via claude.ai Integrations' },
+    { domain: 'Code & GitHub', triggers: ['Show my repo connections…', 'Sync from GitHub…'], description: 'Repository connections and code sync' },
+];
+const EXPERIENCES = [
+    { id: 'first_light', num: 1, name: 'First Light', tier: 1, tierName: 'Orient & Equip', action: 'Ask a question about your business — try "What do we know about [topic]?"', signal: 'First grounded, cited answer about your company' },
+    { id: 'feed_it', num: 2, name: 'Feed It', tier: 1, tierName: 'Orient & Equip', action: 'Add something to your workspace — share a URL, document, or file.', signal: 'First successful content ingestion' },
+    { id: 'build_your_map', num: 3, name: 'Build Your Map', tier: 1, tierName: 'Orient & Equip', action: 'Organize your work — ask to create a collection, build a portfolio, or structure your business.', signal: 'First organizational write operation' },
+    { id: 'connect_your_tools', num: 4, name: 'Connect Your Tools', tier: 1, tierName: 'Orient & Equip', action: 'Connect Slack and Gmail through claude.ai Integrations — type "How do I connect my tools?" for a walkthrough.', signal: 'Connectors active — email and Slack flowing into your workspace' },
+    { id: 'morning_brief', num: 5, name: 'Morning Brief', tier: 2, tierName: 'The Operating System', action: 'Start a session with "What happened while I was away?" or "Morning brief" — includes email triage, Slack synthesis, and calendar prep.', signal: 'First daily operating picture with email triage, Slack synthesis, and calendar prep' },
+    { id: 'run_sales', num: 6, name: 'Run Sales', tier: 2, tierName: 'The Operating System', action: 'Ask to prepare a proposal, run discovery on a prospect, or build a quote.', signal: 'First compound business deliverable' },
+    { id: 'research_publish', num: 7, name: 'Research & Publish', tier: 2, tierName: 'The Operating System', action: 'Ask to research a topic and publish the findings as institutional knowledge.', signal: 'First published wiki article or KB entry' },
+    { id: 'audit_business', num: 8, name: 'Audit Your Business', tier: 2, tierName: 'The Operating System', action: 'Ask "How healthy is our business?" or request a pulse audit.', signal: 'First scored business health audit' },
+    { id: 'operating_rhythm', num: 9, name: 'Your Operating Rhythm', tier: 3, tierName: 'Agentic Mastery', action: 'Set up weekly reviews, delegate recurring work to crews, and build your voice profile.', signal: 'Return for second session with intent; establish a routine' },
+];
+export function registerPrompts(server, getClientFn) {
+    server.prompt('assistant_system', 'System prompt for the TACIT workspace assistant — includes persona, progressive disclosure, and safety rules.', async () => {
+        if (getClientFn) {
+            try {
+                const client = await getClientFn();
+                const state = await fetchWorkspaceState(client);
+                return userText(buildAssistantSystemPrompt(state));
+            }
+            catch {
+                // fall through to static prompt
+            }
+        }
+        return userText(ASSISTANT_SYSTEM_PROMPT_STATIC);
+    });
     server.prompt('lookup', 'Fetch a specific item or list using a single TACIT read tool.', { request: z.string().describe('What to look up, e.g. "list programs"') }, ({ request }) => userText(`Use exactly one TACIT read tool to answer, without synthesis. Request: ${request}`));
     server.prompt('synthesis', 'Answer a question with grounded synthesis and citations.', { question: z.string().describe('The question to answer') }, ({ question }) => userText(`Call tacit_synthesize for this question and cite the sources it returns. Question: ${question}`));
+    if (!getClientFn)
+        return;
+    // --- welcome: personalized workspace greeting with state summary ---
+    server.prompt('welcome', 'Personalized workspace welcome with state summary and suggested first questions.', { workspace_name: z.string().optional().describe('Override workspace display name') }, async (args) => {
+        const client = await getClientFn();
+        const state = await fetchWorkspaceState(client);
+        const name = args.workspace_name || state.name;
+        const lines = [];
+        lines.push(`Welcome to ${name}.`);
+        lines.push('');
+        const counts = [];
+        if (state.collectionCount > 0)
+            counts.push(`${state.collectionCount} knowledge collection${state.collectionCount === 1 ? '' : 's'}`);
+        if (state.portfolioCount > 0)
+            counts.push(`${state.portfolioCount} portfolio${state.portfolioCount === 1 ? '' : 's'}`);
+        if (state.sourceCount > 0)
+            counts.push(`${state.sourceCount} connected source${state.sourceCount === 1 ? '' : 's'}`);
+        if (counts.length > 0) {
+            lines.push(`Your workspace has ${counts.join(', ')}.`);
+        }
+        else {
+            lines.push('Your workspace is fresh — ready for its first content.');
+        }
+        lines.push('');
+        lines.push('Here are some questions to start with:');
+        let qNum = 1;
+        if (state.collectionNames.length > 0) {
+            lines.push(`  ${qNum++}. "What do we know about ${state.collectionNames[0]}?"`);
+            if (state.collectionNames.length > 1) {
+                lines.push(`  ${qNum++}. "Summarize our knowledge on ${state.collectionNames[1]}"`);
+            }
+        }
+        if (state.portfolioNames.length > 0) {
+            lines.push(`  ${qNum++}. "Show me the ${state.portfolioNames[0]} portfolio"`);
+        }
+        if (qNum === 1) {
+            lines.push('  1. "What can you help me with?"');
+            lines.push('  2. "Help me add my first document"');
+            lines.push('  3. "Show me how to organize my business"');
+        }
+        lines.push('');
+        lines.push('Ask anything about your business — every answer is grounded in your workspace knowledge with cited sources.');
+        return userText(lines.join('\n'));
+    });
+    // --- first_question: content-driven question suggestions ---
+    server.prompt('first_question', 'Content-driven question suggestions drawn from actual workspace data.', {}, async () => {
+        const client = await getClientFn();
+        const state = await fetchWorkspaceState(client);
+        const suggestions = [];
+        for (const name of state.collectionNames.slice(0, 3)) {
+            suggestions.push(`"What do we know about ${name}?"`);
+        }
+        for (const name of state.portfolioNames.slice(0, 2)) {
+            suggestions.push(`"What is the status of ${name}?"`);
+        }
+        if (suggestions.length === 0) {
+            suggestions.push('"What can you help me with?"');
+            suggestions.push('"Help me bring in my first document"');
+            suggestions.push('"Show me how to organize my business"');
+        }
+        const lines = [
+            `Based on what is in ${state.name}, here are questions worth asking:`,
+            '',
+            ...suggestions.map((s, i) => `  ${i + 1}. ${s}`),
+            '',
+            'Pick one, or ask your own — every answer is grounded in your workspace data.',
+        ];
+        return userText(lines.join('\n'));
+    });
+    // --- explore: NL capability browser, zero tool names ---
+    server.prompt('explore', 'Browse what your workspace can do, organized by what you want to accomplish.', { domain: z.string().optional().describe('Filter to a specific domain, e.g. "sales" or "knowledge"') }, async (args) => {
+        const filter = args.domain?.toLowerCase();
+        const domains = filter
+            ? CAPABILITY_DOMAINS.filter(d => d.domain.toLowerCase().includes(filter) ||
+                d.description.toLowerCase().includes(filter))
+            : CAPABILITY_DOMAINS;
+        if (domains.length === 0) {
+            return userText(`No capabilities match "${args.domain}". Available domains: ${CAPABILITY_DOMAINS.map(d => d.domain).join(', ')}`);
+        }
+        const lines = [
+            filter ? `Capabilities matching "${args.domain}":` : 'Everything your workspace can do:',
+            '',
+        ];
+        for (const d of domains) {
+            lines.push(`**${d.domain}** — ${d.description}`);
+            lines.push(`  Try: ${d.triggers.join(' · ')}`);
+            lines.push('');
+        }
+        lines.push(`${CAPABILITY_DOMAINS.length} capability domains. Describe what you need in your own words.`);
+        return userText(lines.join('\n'));
+    });
+    // --- whats_next: progressive experience suggestion ---
+    server.prompt('whats_next', 'Suggest the next onboarding experience based on what you have already completed.', {
+        completed: z.string().optional().describe('Comma-separated experience IDs already completed (e.g. "first_light,feed_it")'),
+    }, async (args) => {
+        const completedIds = (args.completed || '')
+            .split(',')
+            .map(s => s.trim().toLowerCase())
+            .filter(Boolean);
+        const completedSet = new Set(completedIds);
+        const tier1 = EXPERIENCES.filter(e => e.tier === 1);
+        const tier2 = EXPERIENCES.filter(e => e.tier === 2);
+        const tier3 = EXPERIENCES.filter(e => e.tier === 3);
+        const tier1Complete = tier1.every(e => completedSet.has(e.id));
+        let next;
+        if (!tier1Complete) {
+            next = tier1.find(e => !completedSet.has(e.id));
+        }
+        else {
+            next = tier2.find(e => !completedSet.has(e.id));
+            if (!next)
+                next = tier3.find(e => !completedSet.has(e.id));
+        }
+        if (!next) {
+            return userText('You have completed all nine experiences — you are a TACIT power user.\n\n' +
+                'From here, build your own operating rhythm: set up recurring briefs, delegate complex tasks to crews, ' +
+                'and let the system learn your patterns. Ask "What can I do next?" any time.');
+        }
+        const lines = [
+            `Progress: ${completedIds.length} of 9 experiences complete.`,
+            '',
+            `**Next: Experience ${next.num} — ${next.name}** (${next.tierName})`,
+            '',
+            next.action,
+            '',
+            `When complete: ${next.signal}`,
+        ];
+        if (next.tier === 2 && tier1Complete) {
+            const otherTier2 = tier2.filter(e => e.id !== next.id && !completedSet.has(e.id));
+            if (otherTier2.length > 0) {
+                lines.push('');
+                lines.push(`Also available: ${otherTier2.map(e => e.name).join(', ')} — Tier 2 experiences work in any order.`);
+            }
+        }
+        return userText(lines.join('\n'));
+    });
+    // --- setup_guide: Slack + Gmail connector walkthrough ---
+    server.prompt('setup_guide', 'Step-by-step guide to connect Slack and Gmail through claude.ai Integrations.', { connector: z.string().optional().describe('Which connector: "slack", "gmail", or "both" (default)') }, async (args) => {
+        const which = (args.connector || 'both').toLowerCase();
+        const showSlack = which === 'slack' || which === 'both';
+        const showGmail = which === 'gmail' || which === 'both';
+        const lines = [];
+        lines.push('Connect your tools to give TACIT access to your communications.');
+        lines.push('This is done through claude.ai — not the CLI.');
+        lines.push('');
+        if (showSlack) {
+            lines.push('**Connect Slack**');
+            lines.push('  1. Open claude.ai in your browser');
+            lines.push('  2. Go to Settings → Integrations (or click your profile → Integrations)');
+            lines.push('  3. Find "Slack" and click Connect');
+            lines.push('  4. Authorize access to your Slack workspace');
+            lines.push('  5. Select which channels to make available');
+            lines.push('  6. Return to Claude Code — Slack data now flows into your sessions');
+            lines.push('');
+            lines.push('  Once connected, your Morning Brief includes overnight Slack activity.');
+            lines.push('');
+        }
+        if (showGmail) {
+            lines.push('**Connect Gmail**');
+            lines.push('  1. Open claude.ai in your browser');
+            lines.push('  2. Go to Settings → Integrations');
+            lines.push('  3. Find "Gmail" and click Connect');
+            lines.push('  4. Sign in with your Google account and grant access');
+            lines.push('  5. Return to Claude Code — email data now flows into your sessions');
+            lines.push('');
+            lines.push('  Once connected, your Morning Brief includes email triage using the 4D method:');
+            lines.push('  Delete (discard), Do (act now), Delegate (forward), Defer (schedule).');
+            lines.push('');
+        }
+        lines.push('After connecting, try Experience 5 — Morning Brief — to see everything synthesized into a daily operating picture.');
+        return userText(lines.join('\n'));
+    });
 }

package/dist/tools/github.d.ts

@@ -0,0 +1,61 @@
+/**
+ * GitHub connection tools — list, disconnect and reconnect GitHub sync
+ * connections (BUG-305).
+ *
+ * Routes (Axum, all under /api/v1/integrations/github):
+ *   GET  /connections[?connection_id=<uuid>]
+ *   POST /:connection_id/disconnect
+ *   POST /:connection_id/reconnect
+ */
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TacitClient } from '../client.js';
+export interface ToolRequest {
+    execute(): Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+        isError?: boolean;
+    }>;
+}
+export declare const listConnectionsInputSchema: z.ZodObject<{
+    connection_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    connection_id?: string | undefined;
+}, {
+    connection_id?: string | undefined;
+}>;
+export type ListConnectionsInput = z.infer<typeof listConnectionsInputSchema>;
+export declare const LIST_CONNECTIONS_TOOL_DEF: {
+    name: "tacit_github_list_connections";
+    description: string;
+};
+export declare function buildListConnectionsRequest(client: TacitClient, input: ListConnectionsInput): ToolRequest;
+export declare const disconnectConnectionInputSchema: z.ZodObject<{
+    connection_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    connection_id: string;
+}, {
+    connection_id: string;
+}>;
+export type DisconnectConnectionInput = z.infer<typeof disconnectConnectionInputSchema>;
+export declare const DISCONNECT_CONNECTION_TOOL_DEF: {
+    name: "tacit_github_disconnect_connection";
+    description: string;
+};
+export declare function buildDisconnectConnectionRequest(client: TacitClient, input: DisconnectConnectionInput): ToolRequest;
+export declare const reconnectConnectionInputSchema: z.ZodObject<{
+    connection_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    connection_id: string;
+}, {
+    connection_id: string;
+}>;
+export type ReconnectConnectionInput = z.infer<typeof reconnectConnectionInputSchema>;
+export declare const RECONNECT_CONNECTION_TOOL_DEF: {
+    name: "tacit_github_reconnect_connection";
+    description: string;
+};
+export declare function buildReconnectConnectionRequest(client: TacitClient, input: ReconnectConnectionInput): ToolRequest;
+export declare function registerGithubTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;

package/dist/tools/github.js

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MIT
+/**
+ * GitHub connection tools — list, disconnect and reconnect GitHub sync
+ * connections (BUG-305).
+ *
+ * Routes (Axum, all under /api/v1/integrations/github):
+ *   GET  /connections[?connection_id=<uuid>]
+ *   POST /:connection_id/disconnect
+ *   POST /:connection_id/reconnect
+ */
+import { z } from 'zod';
+import { 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_github_list_connections ──────────────────────────────────────────
+export const listConnectionsInputSchema = z.object({
+    connection_id: z.string().uuid().optional().describe('Return only this connection'),
+});
+export const LIST_CONNECTIONS_TOOL_DEF = {
+    name: 'tacit_github_list_connections',
+    description: 'List GitHub sync connections for the current workspace with status, last_polled_at, last_synced_at, disconnected_at/by, file_link_count and max_link_last_synced_at. Route: GET /api/v1/integrations/github/connections.',
+};
+export function buildListConnectionsRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.get('/api/v1/integrations/github/connections', input.connection_id ? { connection_id: input.connection_id } : undefined);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_github_list_connections');
+            }
+        },
+    };
+}
+// ─── tacit_github_disconnect_connection ─────────────────────────────────────
+export const disconnectConnectionInputSchema = z.object({
+    connection_id: z.string().uuid().describe('GitHub connection to disconnect'),
+});
+export const DISCONNECT_CONNECTION_TOOL_DEF = {
+    name: 'tacit_github_disconnect_connection',
+    description: 'Disconnect a GitHub sync connection. APPROVAL-TIER: confirm with the user before calling. Stops polling and sync; existing history and file links are kept. Requires auth.manage. Route: POST /api/v1/integrations/github/{connection_id}/disconnect.',
+};
+export function buildDisconnectConnectionRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.post(`/api/v1/integrations/github/${input.connection_id}/disconnect`, {});
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_github_disconnect_connection');
+            }
+        },
+    };
+}
+// ─── tacit_github_reconnect_connection ──────────────────────────────────────
+export const reconnectConnectionInputSchema = z.object({
+    connection_id: z.string().uuid().describe('GitHub connection to reconnect'),
+});
+export const RECONNECT_CONNECTION_TOOL_DEF = {
+    name: 'tacit_github_reconnect_connection',
+    description: 'Reconnect a previously disconnected GitHub sync connection. APPROVAL-TIER: confirm with the user before calling. Resumes polling and sync. Requires auth.manage. Route: POST /api/v1/integrations/github/{connection_id}/reconnect.',
+};
+export function buildReconnectConnectionRequest(client, input) {
+    return {
+        async execute() {
+            try {
+                const result = await client.post(`/api/v1/integrations/github/${input.connection_id}/reconnect`, {});
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (err) {
+                return apiErrorResult(err, 'tacit_github_reconnect_connection');
+            }
+        },
+    };
+}
+// ─── Registration ───────────────────────────────────────────────────────────
+export function registerGithubTools(server, getClientFn) {
+    server.tool('tacit_github_list_connections', LIST_CONNECTIONS_TOOL_DEF.description, listConnectionsInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildListConnectionsRequest(client, args).execute();
+    });
+    server.tool('tacit_github_disconnect_connection', DISCONNECT_CONNECTION_TOOL_DEF.description, disconnectConnectionInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildDisconnectConnectionRequest(client, args).execute();
+    });
+    server.tool('tacit_github_reconnect_connection', RECONNECT_CONNECTION_TOOL_DEF.description, reconnectConnectionInputSchema.shape, async (args) => {
+        const client = await getClientFn();
+        return buildReconnectConnectionRequest(client, args).execute();
+    });
+}

package/dist/tools/registry.d.ts

@@ -1,6 +1,6 @@
 /**
  * Compile-time tool classification. Governs which tools may be called over HTTPS.
- * Partition: 6 stdio_only + 15 admin_only + 2 gate_only + 110 https = 133.
+ * Partition: 6 stdio_only + 17 admin_only + 2 gate_only + 121 https = 146.
  */
 export type ToolTransport = 'https' | 'stdio_only' | 'admin_only' | 'gate_only';
 export type ToolClass = 'read' | 'write' | 'admin' | 'dispatch';

package/dist/tools/registry.js

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 /**
  * Compile-time tool classification. Governs which tools may be called over HTTPS.
- * Partition: 6 stdio_only + 15 admin_only + 2 gate_only + 110 https = 133.
+ * Partition: 6 stdio_only + 17 admin_only + 2 gate_only + 121 https = 146.
  */
 const STDIO_ONLY = [
     'tacit_ingest_file',
@@ -25,6 +25,8 @@ const ADMIN_ONLY = [
     'tacit_lake_folder_merge',
     'tacit_lake_folder_remove',
     'tacit_lake_delete_catalog_item',
+    'tacit_github_disconnect_connection',
+    'tacit_github_reconnect_connection',
     'tacit_compose',
     'tacit_converse',
 ];
@@ -66,6 +68,7 @@ const READ_TOOLS = [
     'tacit_lake_folder_list',
     'tacit_lake_list_proposals',
     'tacit_lake_list_sources',
+    'tacit_github_list_connections',
     'tacit_lake_manifest',
     'tacit_lake_resolve',
     'tacit_lake_sync_status',
@@ -90,10 +93,16 @@ const READ_TOOLS = [
     'tacit_shared_read',
     'tacit_shared_search',
     'tacit_synthesize',
+    'tacit_voice_get_profile',
+    'tacit_voice_get_stats',
+    'tacit_voice_list_profiles',
     'tacit_web_url',
+    'tacit_wiki_classify',
+    'tacit_wiki_validate',
 ];
 const DISPATCH_TOOLS = [
     'tacit_agent_delegate',
+    'tacit_compose_in_voice',
     'tacit_dispatch_crew',
     'tacit_kb_pull_source',
     'tacit_lake_trigger_sync',
@@ -152,6 +161,10 @@ const WRITE_TOOLS = [
     'tacit_research_prepare',
     'tacit_share_artifact',
     'tacit_switch_workspace',
+    'tacit_voice_upload_sample',
+    'tacit_wiki_author',
+    'tacit_wiki_override',
+    'tacit_wiki_write',
 ];
 function build() {
     const map = new Map();
@@ -178,8 +191,8 @@ function build() {
         if (!exclusive.has(n))
             add(n, classOf(n), 'https', false);
     }
-    if (map.size !== 133)
-        throw new Error(`tool registry expected 133 tools, got ${map.size}`);
+    if (map.size !== 146)
+        throw new Error(`tool registry expected 146 tools, got ${map.size}`);
     return map;
 }
 export const TOOL_REGISTRY = build();

package/dist/tools/synthesize.d.ts

@@ -20,6 +20,8 @@ export declare const synthesizeInputSchema: z.ZodObject<{
     origin: z.ZodOptional<z.ZodString>;
     synthesis_mode: z.ZodOptional<z.ZodEnum<["burst", "orbit", "crew_compose"]>>;
     max_turns: z.ZodOptional<z.ZodNumber>;
+    voice_mode: z.ZodOptional<z.ZodEnum<["voice_on", "voice_off", "voice_only"]>>;
+    voice_profile_id: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     query: string;
     workspace_id?: string | undefined;
@@ -30,6 +32,8 @@ export declare const synthesizeInputSchema: z.ZodObject<{
     program_ids?: string[] | undefined;
     synthesis_mode?: "burst" | "orbit" | "crew_compose" | undefined;
     max_turns?: number | undefined;
+    voice_mode?: "voice_on" | "voice_off" | "voice_only" | undefined;
+    voice_profile_id?: string | undefined;
 }, {
     query: string;
     workspace_id?: string | undefined;
@@ -40,6 +44,8 @@ export declare const synthesizeInputSchema: z.ZodObject<{
     program_ids?: string[] | undefined;
     synthesis_mode?: "burst" | "orbit" | "crew_compose" | undefined;
     max_turns?: number | undefined;
+    voice_mode?: "voice_on" | "voice_off" | "voice_only" | undefined;
+    voice_profile_id?: string | undefined;
 }>;
 export type SynthesizeInput = z.infer<typeof synthesizeInputSchema>;
 export declare const SYNTHESIZE_TOOL_DEF: {
@@ -92,6 +98,15 @@ export declare const SYNTHESIZE_TOOL_DEF: {
                 minimum: number;
                 description: string;
             };
+            voice_mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            voice_profile_id: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/tools/synthesize.js

@@ -20,6 +20,10 @@ export const synthesizeInputSchema = z.object({
     origin: z.string().optional().describe('Optional origin filter (e.g., PYRAMID, LAKE_SYNC, MANUAL) to scope results'),
     synthesis_mode: z.enum(['burst', 'orbit', 'crew_compose']).optional().describe('Synthesis mode: burst (fast retrieval), orbit (agentic multi-turn), crew_compose (crew artifact generation). Default: burst.'),
     max_turns: z.number().int().min(1).optional().describe('Max agentic loop iterations for orbit/crew_compose mode (1-12 for orbit, 1-54 for crew_compose).'),
+    voice_mode: z.enum(['voice_on', 'voice_off', 'voice_only']).optional()
+        .describe('Voice personalization mode. voice_on: apply active profile, voice_off: suppress, voice_only: voice without synthesis.'),
+    voice_profile_id: z.string().optional()
+        .describe('Specific voice profile UUID. Omit to use the active profile when voice_mode is set.'),
 });
 export const SYNTHESIZE_TOOL_DEF = {
     name: 'tacit_synthesize',
@@ -38,6 +42,8 @@ export const SYNTHESIZE_TOOL_DEF = {
             origin: { type: 'string', description: 'Optional origin filter (e.g., PYRAMID, LAKE_SYNC, MANUAL) to scope results' },
             synthesis_mode: { type: 'string', enum: ['burst', 'orbit', 'crew_compose'], description: 'Synthesis mode: burst (fast retrieval), orbit (agentic multi-turn), crew_compose (crew artifact generation). Default: burst.' },
             max_turns: { type: 'integer', minimum: 1, description: 'Max agentic loop iterations for orbit/crew_compose mode (1-12 for orbit, 1-54 for crew_compose).' },
+            voice_mode: { type: 'string', enum: ['voice_on', 'voice_off', 'voice_only'], description: 'Voice personalization mode. Supports optional voice_mode for voice-personalized output.' },
+            voice_profile_id: { type: 'string', description: 'Specific voice profile UUID. Omit to use the active profile when voice_mode is set.' },
         },
         required: ['query'],
     },
@@ -49,7 +55,7 @@ export const SYNTHESIZE_TOOL_DEF = {
 export function buildSynthesizeRequest(client, input) {
     return {
         async execute() {
-            const { query, scope, stream, workspace_id, collection_ids, program_ids, origin, synthesis_mode, max_turns } = input;
+            const { query, scope, stream, workspace_id, collection_ids, program_ids, origin, synthesis_mode, max_turns, voice_mode, voice_profile_id } = input;
             const body = { query };
             if (scope)
                 body['scope'] = scope;
@@ -65,6 +71,10 @@ export function buildSynthesizeRequest(client, input) {
                 body['synthesis_mode'] = synthesis_mode;
             if (max_turns)
                 body['max_turns'] = max_turns;
+            if (voice_mode)
+                body['voice_mode'] = voice_mode;
+            if (voice_profile_id)
+                body['voice_profile_id'] = voice_profile_id;
             try {
                 if (stream) {
                     // SSE path: POST /api/v1/mind/synthesize/stream
@@ -138,6 +148,10 @@ const SYNTH_SCHEMA = {
     origin: z.string().optional().describe('Optional origin filter (e.g., PYRAMID, LAKE_SYNC, MANUAL) to scope results'),
     synthesis_mode: z.enum(['burst', 'orbit', 'crew_compose']).optional().describe('Synthesis mode: burst (fast retrieval), orbit (agentic multi-turn), crew_compose (crew artifact generation). Default: burst.'),
     max_turns: z.number().int().min(1).optional().describe('Max agentic loop iterations for orbit/crew_compose mode (1-12 for orbit, 1-54 for crew_compose).'),
+    voice_mode: z.enum(['voice_on', 'voice_off', 'voice_only']).optional()
+        .describe('Voice personalization mode. voice_on: apply active profile, voice_off: suppress, voice_only: voice without synthesis.'),
+    voice_profile_id: z.string().optional()
+        .describe('Specific voice profile UUID. Omit to use the active profile when voice_mode is set.'),
 };
 export function registerSynthesizeTools(server, getClientFn) {
     const handler = async (args) => {

package/dist/tools/voice.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Voice resonance tools — profile management, stats, sample upload,
+ * and voice-applied composition via crew_compose + voice_mode.
+ *
+ * Routes (Axum, under /api/v1/voice):
+ *   GET  /profiles           — list voice profiles
+ *   GET  /profiles/:id       — get profile detail
+ *   GET  /profiles/:id/stats — get profile statistics
+ *   POST /profiles/:id/samples — upload a voice sample
+ *
+ * compose_in_voice uses POST /api/v1/mind/synthesize with
+ * synthesis_mode=crew_compose + voice_mode=voice_on.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TacitClient } from '../client.js';
+export declare function registerVoiceTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;

package/dist/tools/voice.js

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Voice resonance tools — profile management, stats, sample upload,
+ * and voice-applied composition via crew_compose + voice_mode.
+ *
+ * Routes (Axum, under /api/v1/voice):
+ *   GET  /profiles           — list voice profiles
+ *   GET  /profiles/:id       — get profile detail
+ *   GET  /profiles/:id/stats — get profile statistics
+ *   POST /profiles/:id/samples — upload a voice sample
+ *
+ * compose_in_voice uses POST /api/v1/mind/synthesize with
+ * synthesis_mode=crew_compose + voice_mode=voice_on.
+ */
+import { z } from 'zod';
+import { apiErrorResult } from './errors.js';
+import { buildSynthesizeRequest } from './synthesize.js';
+export function registerVoiceTools(server, getClientFn) {
+    // ── tacit_voice_list_profiles ──────────────────────────────────────────────
+    server.tool('tacit_voice_list_profiles', 'List your voice profiles with name, active status, sample count, and quality indicators. Use when someone asks about their voice profiles or writing style settings.', {}, async () => {
+        try {
+            const client = await getClientFn();
+            const result = await client.get('/api/v1/voice/profiles');
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        }
+        catch (err) {
+            return apiErrorResult(err, '/api/v1/voice/profiles');
+        }
+    });
+    // ── tacit_voice_get_profile ────────────────────────────────────────────────
+    server.tool('tacit_voice_get_profile', 'Get full details for a specific voice profile including constellation label, quality score, and configuration. Use when someone wants to inspect a particular voice profile.', {
+        profile_id: z.string().describe('Voice profile UUID'),
+    }, async ({ profile_id }) => {
+        try {
+            const client = await getClientFn();
+            const result = await client.get(`/api/v1/voice/profiles/${profile_id}`);
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        }
+        catch (err) {
+            return apiErrorResult(err, `/api/v1/voice/profiles/${profile_id}`);
+        }
+    });
+    // ── tacit_voice_get_stats ──────────────────────────────────────────────────
+    server.tool('tacit_voice_get_stats', 'Get statistics for a voice profile — sample count, quality score, constellation breakdown, and training status. Use when someone asks how good their voice profile is or wants quality details.', {
+        profile_id: z.string().describe('Voice profile UUID'),
+    }, async ({ profile_id }) => {
+        try {
+            const client = await getClientFn();
+            const result = await client.get(`/api/v1/voice/profiles/${profile_id}/stats`);
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        }
+        catch (err) {
+            return apiErrorResult(err, `/api/v1/voice/profiles/${profile_id}/stats`);
+        }
+    });
+    // ── tacit_voice_upload_sample ──────────────────────────────────────────────
+    server.tool('tacit_voice_upload_sample', 'Upload a text sample to train a voice profile. The sample teaches the system your writing style. Use when someone provides text they want added to their voice profile.', {
+        profile_id: z.string().describe('Voice profile UUID to add the sample to'),
+        content: z.string().min(1).describe('Text content of the writing sample'),
+        label: z.string().optional().describe('Optional label for the sample (e.g. "blog post", "email")'),
+    }, async ({ profile_id, content, label }) => {
+        try {
+            const client = await getClientFn();
+            const body = { content };
+            if (label)
+                body['label'] = label;
+            const result = await client.post(`/api/v1/voice/profiles/${profile_id}/samples`, body);
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        }
+        catch (err) {
+            return apiErrorResult(err, `/api/v1/voice/profiles/${profile_id}/samples`);
+        }
+    });
+    // ── tacit_compose_in_voice ─────────────────────────────────────────────────
+    server.tool('tacit_compose_in_voice', 'Compose an artifact in your writing voice. Combines crew-based artifact generation with voice personalization in a single call. Use when someone says "write this in my voice" or "compose a brief in my style".', {
+        query: z.string().min(1).describe('Composition prompt — what to write'),
+        voice_profile_id: z.string().optional().describe('Specific voice profile UUID. Omit to use the active profile.'),
+        scope: z.string().optional().describe('Optional scope filter (e.g. portfolio or program id)'),
+        workspace_id: z.string().optional().describe('Optional workspace UUID'),
+        collection_ids: z.array(z.string()).optional().describe('Optional collection UUIDs to scope synthesis to'),
+        program_ids: z.array(z.string()).optional().describe('Optional program UUIDs to scope synthesis to'),
+    }, async (args) => {
+        try {
+            const client = await getClientFn();
+            const input = {
+                query: args.query,
+                synthesis_mode: 'crew_compose',
+                voice_mode: 'voice_on',
+                voice_profile_id: args.voice_profile_id,
+                scope: args.scope,
+                workspace_id: args.workspace_id,
+                collection_ids: args.collection_ids,
+                program_ids: args.program_ids,
+            };
+            return buildSynthesizeRequest(client, input).execute();
+        }
+        catch (err) {
+            return apiErrorResult(err, 'compose_in_voice');
+        }
+    });
+}

package/dist/tools/wiki.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Wiki governance tools — validate articles against governance rules,
+ * apply overrides, write to wiki repos, and author content via LLM.
+ *
+ * Routes (Axum, all under /api/v1/wiki):
+ *   POST /validate  — validate content against WX governance rules
+ *   POST /override  — propose or apply governance overrides (autonomy-tiered)
+ *   POST /write     — commit article to wiki repo (pre-validates)
+ *   POST /author    — generate or rewrite article via CLIProxy (W3)
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { TacitClient } from '../client.js';
+export declare function registerWikiTools(server: McpServer, getClientFn: () => Promise<TacitClient>): void;

package/dist/tools/wiki.js

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Wiki governance tools — validate articles against governance rules,
+ * apply overrides, write to wiki repos, and author content via LLM.
+ *
+ * Routes (Axum, all under /api/v1/wiki):
+ *   POST /validate  — validate content against WX governance rules
+ *   POST /override  — propose or apply governance overrides (autonomy-tiered)
+ *   POST /write     — commit article to wiki repo (pre-validates)
+ *   POST /author    — generate or rewrite article via CLIProxy (W3)
+ */
+import { z } from 'zod';
+import { 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_wiki_validate ───────────────────────────────────────────────────
+export function registerWikiTools(server, getClientFn) {
+    server.tool('tacit_wiki_validate', 'Validate wiki article content against 33 governance rules (WX-01..WX-33). ' +
+        'Returns verdict (PASS/WARN/FAIL), score breakdown (readability, structure, voice), ' +
+        'Dale-Chall readability score, persona coherence score, and individual findings. ' +
+        'Route: POST /api/v1/wiki/validate.', {
+        content: z.string().min(1).describe('Full article content (markdown with YAML frontmatter)'),
+        wiki: z.enum(['eng', 'delight']).describe('Target wiki: eng (engineering) or delight (user-facing)'),
+        persona: z.string().optional().describe('Persona key (developer, operator, end-user, decision-maker). Defaults to wiki default.'),
+        content_type: z.enum(['Tutorial', 'How-To', 'Reference', 'Explanation', 'Runbook']).optional().describe('Content type for template-specific rules. Falls back to frontmatter content_type field.'),
+    }, async (args) => {
+        const client = await getClientFn();
+        try {
+            const resp = await client.post('/api/v1/wiki/validate', {
+                content: args.content,
+                wiki: args.wiki,
+                persona: args.persona,
+                content_type: args.content_type,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(resp, null, 2) }],
+            };
+        }
+        catch (err) {
+            return apiErrorResult(err, 'tacit_wiki_validate');
+        }
+    });
+    // ─── tacit_wiki_override ─────────────────────────────────────────────────
+    server.tool('tacit_wiki_override', 'Propose or apply a governance override for a specific rule on an article. ' +
+        'Autonomy-tiered: SCRIBE=forbidden, MENTAT=proposes (24h expiry, needs TWIN approval), ' +
+        'TWIN=applies directly (90-day expiry). Overrides are stored in article frontmatter. ' +
+        'Route: POST /api/v1/wiki/override.', {
+        path: z.string().min(1).describe('Article path within the wiki (e.g., "architecture/data-model.mdx")'),
+        wiki: z.enum(['eng', 'delight']).describe('Target wiki'),
+        mode: z.enum(['per_finding', 'blanket_warn']).describe('Override a single rule or all Warn-severity findings'),
+        rule_id: z.string().optional().describe('Rule ID to override (e.g., "WX-01"). Required for per_finding mode.'),
+        reason: z.string().min(1).describe('Justification for the override'),
+        accept_proposal_id: z.string().uuid().optional().describe('UUID of a MENTAT-proposed override to accept (TWIN only). Links acceptance to the original proposal.'),
+    }, async (args) => {
+        const client = await getClientFn();
+        try {
+            const resp = await client.post('/api/v1/wiki/override', {
+                path: args.path,
+                wiki: args.wiki,
+                mode: args.mode,
+                rule_id: args.rule_id,
+                reason: args.reason,
+                accept_proposal_id: args.accept_proposal_id,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(resp, null, 2) }],
+            };
+        }
+        catch (err) {
+            return apiErrorResult(err, 'tacit_wiki_override');
+        }
+    });
+    // ─── tacit_wiki_write ────────────────────────────────────────────────────
+    server.tool('tacit_wiki_write', 'Write an article to the wiki repository. Pre-validates content — rejects if any Error-severity ' +
+        'findings exist. Commits to the wiki git repo (eng or delight) and returns the commit SHA. ' +
+        'Returns 503 if the wiki repo is not available (CI/beta/prod environments). ' +
+        'Route: POST /api/v1/wiki/write.', {
+        content: z.string().min(1).describe('Full article content (markdown with YAML frontmatter)'),
+        path: z.string().min(1).describe('File path within the wiki (e.g., "architecture/data-model.mdx")'),
+        wiki: z.enum(['eng', 'delight']).describe('Target wiki'),
+        commit_message: z.string().optional().describe('Git commit message (auto-generated if omitted)'),
+    }, async (args) => {
+        const client = await getClientFn();
+        try {
+            const resp = await client.post('/api/v1/wiki/write', {
+                content: args.content,
+                path: args.path,
+                wiki: args.wiki,
+                commit_message: args.commit_message,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(resp, null, 2) }],
+            };
+        }
+        catch (err) {
+            return apiErrorResult(err, 'tacit_wiki_write');
+        }
+    });
+    // ─── tacit_wiki_classify ─────────────────────────────────────────────────
+    server.tool('tacit_wiki_classify', 'Classify wiki content: determine target wiki (eng/delight/split), content type ' +
+        '(Tutorial/How-To/Reference/Explanation/Runbook), recommended path, and persona. ' +
+        'Uses LLM-backed Q1-Q4 decision tree. Requires CLIProxy and FEATURE_WIKI_CLASSIFY flag. ' +
+        'Route: POST /api/v1/wiki/classify.', {
+        content: z.string().min(1).describe('Full article content to classify'),
+        wiki: z.string().optional().describe('Optional wiki hint (eng or delight). The classifier may override this.'),
+    }, async (args) => {
+        const client = await getClientFn();
+        try {
+            const resp = await client.post('/api/v1/wiki/classify', {
+                content: args.content,
+                wiki: args.wiki,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(resp, null, 2) }],
+            };
+        }
+        catch (err) {
+            return apiErrorResult(err, 'tacit_wiki_classify');
+        }
+    });
+    // ─── tacit_wiki_author ───────────────────────────────────────────────────
+    server.tool('tacit_wiki_author', 'Generate or rewrite wiki content using CLIProxy LLM. Draft mode creates a new article ' +
+        'from a topic; rewrite mode fixes governance findings while preserving content. ' +
+        'Requires CLIProxy (port 8317) and FEATURE_WIKI_AUTHOR flag. ' +
+        'Route: POST /api/v1/wiki/author.', {
+        mode: z.enum(['draft', 'rewrite']).describe('draft = new article from topic, rewrite = fix existing'),
+        wiki: z.enum(['eng', 'delight']).describe('Target wiki'),
+        persona: z.string().optional().describe('Persona key. Defaults to wiki default.'),
+        topic: z.string().optional().describe('Topic for draft mode'),
+        content: z.string().optional().describe('Existing content for rewrite mode'),
+        validation_findings: z.array(z.object({
+            rule_id: z.string(),
+            severity: z.enum(['WARN', 'ERROR']),
+            message: z.string(),
+            line: z.number().optional(),
+            overridable: z.boolean(),
+            category: z.enum(['frontmatter', 'structure', 'readability', 'voice', 'cross_link']),
+        })).optional().describe('Findings from tacit_wiki_validate to address in rewrite'),
+    }, async (args) => {
+        const client = await getClientFn();
+        try {
+            const resp = await client.post('/api/v1/wiki/author', {
+                mode: args.mode,
+                wiki: args.wiki,
+                persona: args.persona,
+                topic: args.topic,
+                content: args.content,
+                validation_findings: args.validation_findings,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(resp, null, 2) }],
+            };
+        }
+        catch (err) {
+            return apiErrorResult(err, 'tacit_wiki_author');
+        }
+    });
+}

package/dist/transport.js

@@ -199,10 +199,11 @@ export async function startHttpTransport(server) {
             sendJson(res, 500, { error: 'internal error' });
         });
     });
+    const bindHost = process.env['MCP_BIND_HOST'] ?? '0.0.0.0';
     await new Promise((resolve, reject) => {
         httpServer.once('error', reject);
-        httpServer.listen(port, '127.0.0.1', () => {
-            process.stderr.write(`[tacit-mcp-http] listening on 127.0.0.1:${port}\n`);
+        httpServer.listen(port, bindHost, () => {
+            process.stderr.write(`[tacit-mcp-http] listening on ${bindHost}:${port}\n`);
             resolve();
         });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tacitai/mcp-server",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "stdio MCP server wrapping Tacit /api/v1 REST/SSE API",
   "license": "MIT",
   "repository": {