@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/hooks/workspace/workspaceLocalState.js

@@ -0,0 +1,101 @@
+import { isReservedWorkspaceId, normalizeWorkspaceStorageScope, normalizeWorkspaceStorageScopeLegacy } from '../../utils/workspaceIdentity';
+const WORKSPACE_CONTEXT_KEY_PREFIX = 'taskforce.workspaceContext.v2';
+const APP_UI_STATE_STORAGE_KEY_PREFIX = 'taskforce.uiState.app.v1';
+const BOOTSTRAP_DEBUG_LOG_KEY = 'taskforce.bootstrapDebug.v1';
+export function generateClientUuid() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return `${Date.now().toString(16)}-${Math.random().toString(16).slice(2, 14)}`;
+}
+function isBootstrapDebugLoggingEnabled() {
+    if (typeof window === 'undefined')
+        return false;
+    try {
+        const raw = String(window.localStorage.getItem(BOOTSTRAP_DEBUG_LOG_KEY) || '').trim().toLowerCase();
+        return raw === '1' || raw === 'true' || raw === 'on' || raw === 'yes';
+    }
+    catch {
+        return false;
+    }
+}
+export function logBootstrapDebug(event, details) {
+    if (!isBootstrapDebugLoggingEnabled())
+        return;
+    const payload = details && typeof details === 'object' ? details : {};
+    console.info('[Taskforce Bootstrap]', event, payload);
+}
+function buildWorkspaceContextStorageKey(scopeRaw) {
+    const scope = normalizeWorkspaceStorageScope(scopeRaw);
+    return `${WORKSPACE_CONTEXT_KEY_PREFIX}.${scope}`;
+}
+function buildLegacyWorkspaceContextStorageKey(scopeRaw) {
+    const scope = normalizeWorkspaceStorageScopeLegacy(scopeRaw);
+    return `${WORKSPACE_CONTEXT_KEY_PREFIX}.${scope}`;
+}
+export function readPersistedWorkspaceId(scopeRaw) {
+    if (typeof window === 'undefined')
+        return '';
+    try {
+        const scopedKey = buildWorkspaceContextStorageKey(scopeRaw);
+        const scopedValue = String(window.localStorage.getItem(scopedKey) || '').trim();
+        if (scopedValue && scopedValue.length <= 120 && !/\s/.test(scopedValue))
+            return scopedValue;
+        const legacyScopedKey = buildLegacyWorkspaceContextStorageKey(scopeRaw);
+        const legacyScopedValue = String(window.localStorage.getItem(legacyScopedKey) || '').trim();
+        if (legacyScopedValue && legacyScopedValue.length <= 120 && !/\s/.test(legacyScopedValue)) {
+            window.localStorage.setItem(scopedKey, legacyScopedValue);
+            return legacyScopedValue;
+        }
+        return '';
+    }
+    catch {
+        return '';
+    }
+}
+export function writePersistedWorkspaceId(workspaceId, scopeRaw) {
+    if (typeof window === 'undefined')
+        return;
+    const next = String(workspaceId || '').trim();
+    try {
+        if (!next || isReservedWorkspaceId(next))
+            return;
+        const storageKey = buildWorkspaceContextStorageKey(scopeRaw);
+        const existing = String(window.localStorage.getItem(storageKey) || '').trim();
+        if (!next && existing && existing.toLowerCase() !== 'default') {
+            return;
+        }
+        window.localStorage.setItem(storageKey, next);
+    }
+    catch {
+        // best-effort only
+    }
+}
+function buildAppUiStateStorageKey(scopeRaw) {
+    const scope = normalizeWorkspaceStorageScopeLegacy(scopeRaw);
+    return `${APP_UI_STATE_STORAGE_KEY_PREFIX}.${scope}`;
+}
+export function readPersistedAppUiState(scopeRaw) {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        const raw = window.localStorage.getItem(buildAppUiStateStorageKey(scopeRaw));
+        if (!raw)
+            return null;
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writePersistedAppUiState(state, scopeRaw) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        window.localStorage.setItem(buildAppUiStateStorageKey(scopeRaw), JSON.stringify(state));
+    }
+    catch {
+        // best-effort only
+    }
+}

package/dist/localization/locales/en-US.d.ts

@@ -16,10 +16,7 @@ export interface MessageCatalog {
         dueBeforeScheduled: string;
         overdue: string;
     };
-    schedule: {
-        completedOnlyPastSchedule: string;
-        noUnscheduledLeafTasks: string;
-    };
+    schedule: {};
     taskList: {
         searchPlaceholder: string;
         clearSearchTitle: string;
@@ -49,10 +46,6 @@ export interface MessageCatalog {
         addTaskToCategoryTitle: string;
     };
     actionHeader: {
-        blockedByActiveChildren: string;
-        confirmCascadeComplete: string;
-        confirmCascadeCancel: string;
-        confirmCascadeArchive: string;
         saveChangesTitle: string;
         update: string;
         copyTaskIdTitle: string;

package/dist/localization/locales/en-US.js

@@ -16,10 +16,7 @@ export const enUS = {
         dueBeforeScheduled: 'Due date is before scheduled date.',
         overdue: 'This task is overdue.'
     },
-    schedule: {
-        completedOnlyPastSchedule: 'Only completed work can be scheduled in the past.',
-        noUnscheduledLeafTasks: 'No unscheduled leaf tasks found under "{parentTitle}".'
-    },
+    schedule: {},
     taskList: {
         searchPlaceholder: 'Search tasks...',
         clearSearchTitle: 'Clear search',
@@ -43,16 +40,12 @@ export const enUS = {
         linksParents: 'Parents',
         linksLinked: 'Linked',
         linksUnlinked: 'Unlinked',
-        includeArchive: 'Include Archive',
+        includeArchive: 'Archived',
         noMatchingTasks: 'No matching tasks',
         noActiveTasks: 'No active tasks',
         addTaskToCategoryTitle: 'Add task to {category}'
     },
     actionHeader: {
-        blockedByActiveChildren: 'Complete or cancel all direct child tasks first',
-        confirmCascadeComplete: 'This parent task has {count} active child task(s). Also mark all child tasks as complete?',
-        confirmCascadeCancel: 'This parent task has {count} active child task(s). Also mark all child tasks as cancelled?',
-        confirmCascadeArchive: 'This parent task has {count} child task(s). Also archive all child tasks?',
         saveChangesTitle: 'Save Changes',
         update: 'Update',
         copyTaskIdTitle: 'Click to copy Task ID',
@@ -86,7 +79,7 @@ export const enUS = {
         groupType: 'Type',
         groupPriority: 'Priority',
         groupComplexity: 'Complexity',
-        groupApproach: 'Approach',
+        groupApproach: 'Workflow',
         groupAssignee: 'Assignee',
         groupStatus: 'Status',
         groupHierarchy: 'Hierarchy',
@@ -115,7 +108,7 @@ export const enUS = {
         linksLinked: 'Linked',
         linksUnlinked: 'Unlinked',
         includeArchiveTitle: 'Include archived tasks',
-        includeArchive: 'Include Archive',
+        includeArchive: 'Archived',
         clearFilters: 'Clear Filters',
         noTasksMatchFilters: 'No tasks match current filters.',
         showingWithLinksHint: 'Showing: {parentFilterLabel}. Switch Links to All or clear filters.',

package/dist/localization/locales/es-419.js

@@ -16,10 +16,7 @@ export const es419 = {
         dueBeforeScheduled: 'La fecha de vencimiento es anterior a la fecha programada.',
         overdue: 'Esta tarea esta vencida.'
     },
-    schedule: {
-        completedOnlyPastSchedule: 'Solo el trabajo completado se puede programar en el pasado.',
-        noUnscheduledLeafTasks: 'No se encontraron tareas hoja sin programar en "{parentTitle}".'
-    },
+    schedule: {},
     taskList: {
         searchPlaceholder: 'Buscar tareas...',
         clearSearchTitle: 'Limpiar busqueda',
@@ -49,10 +46,6 @@ export const es419 = {
         addTaskToCategoryTitle: 'Agregar tarea a {category}'
     },
     actionHeader: {
-        blockedByActiveChildren: 'Primero completa o cancela todas las tareas hijas directas',
-        confirmCascadeComplete: 'Esta tarea padre tiene {count} tarea(s) hija(s) activa(s). Tambien quieres marcar todas las tareas hijas como completadas?',
-        confirmCascadeCancel: 'Esta tarea padre tiene {count} tarea(s) hija(s) activa(s). Tambien quieres marcar todas las tareas hijas como canceladas?',
-        confirmCascadeArchive: 'Esta tarea padre tiene {count} tarea(s) hija(s). Tambien quieres archivar todas las tareas hijas?',
         saveChangesTitle: 'Guardar cambios',
         update: 'Actualizar',
         copyTaskIdTitle: 'Haz clic para copiar el ID de la tarea',
@@ -86,7 +79,7 @@ export const es419 = {
         groupType: 'Tipo',
         groupPriority: 'Prioridad',
         groupComplexity: 'Complejidad',
-        groupApproach: 'Enfoque',
+        groupApproach: 'Flujo de trabajo',
         groupAssignee: 'Asignado a',
         groupStatus: 'Estado',
         groupHierarchy: 'Jerarquia',

package/dist/localization/locales/pt-BR.js

@@ -16,10 +16,7 @@ export const ptBR = {
         dueBeforeScheduled: 'A data de vencimento e anterior a data agendada.',
         overdue: 'Esta tarefa esta atrasada.'
     },
-    schedule: {
-        completedOnlyPastSchedule: 'Somente trabalho concluido pode ser agendado no passado.',
-        noUnscheduledLeafTasks: 'Nenhuma tarefa folha nao agendada foi encontrada em "{parentTitle}".'
-    },
+    schedule: {},
     taskList: {
         searchPlaceholder: 'Buscar tarefas...',
         clearSearchTitle: 'Limpar busca',
@@ -49,10 +46,6 @@ export const ptBR = {
         addTaskToCategoryTitle: 'Adicionar tarefa a {category}'
     },
     actionHeader: {
-        blockedByActiveChildren: 'Conclua ou cancele todas as tarefas filhas diretas primeiro',
-        confirmCascadeComplete: 'Esta tarefa pai tem {count} tarefa(s) filha(s) ativa(s). Tambem deseja marcar todas as tarefas filhas como concluidas?',
-        confirmCascadeCancel: 'Esta tarefa pai tem {count} tarefa(s) filha(s) ativa(s). Tambem deseja marcar todas as tarefas filhas como canceladas?',
-        confirmCascadeArchive: 'Esta tarefa pai tem {count} tarefa(s) filha(s). Tambem deseja arquivar todas as tarefas filhas?',
         saveChangesTitle: 'Salvar alteracoes',
         update: 'Atualizar',
         copyTaskIdTitle: 'Clique para copiar o ID da tarefa',
@@ -86,7 +79,7 @@ export const ptBR = {
         groupType: 'Tipo',
         groupPriority: 'Prioridade',
         groupComplexity: 'Complexidade',
-        groupApproach: 'Abordagem',
+        groupApproach: 'Fluxo de trabalho',
         groupAssignee: 'Atribuido para',
         groupStatus: 'Status',
         groupHierarchy: 'Hierarquia',

package/dist/localization/localizationCatalogs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/localization/localizationCatalogs.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { enUS } from './locales/en-US';
+import { es419 } from './locales/es-419';
+import { ptBR } from './locales/pt-BR';
+function collectLeafKeys(input, prefix = '') {
+    if (!input || typeof input !== 'object')
+        return [];
+    return Object.entries(input).flatMap(([key, value]) => {
+        const nextPrefix = prefix ? `${prefix}.${key}` : key;
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            return collectLeafKeys(value, nextPrefix);
+        }
+        return [nextPrefix];
+    });
+}
+describe('Localization catalogs', () => {
+    it('keeps identical key coverage across locales', () => {
+        const enKeys = collectLeafKeys(enUS).sort();
+        const esKeys = collectLeafKeys(es419).sort();
+        const ptKeys = collectLeafKeys(ptBR).sort();
+        expect(esKeys).toEqual(enKeys);
+        expect(ptKeys).toEqual(enKeys);
+    });
+    it('avoids blank translations in non-default locales', () => {
+        const values = [es419, ptBR];
+        for (const catalog of values) {
+            for (const key of collectLeafKeys(catalog)) {
+                const segments = key.split('.');
+                let cursor = catalog;
+                for (const segment of segments)
+                    cursor = cursor?.[segment];
+                expect(typeof cursor).toBe('string');
+                expect(String(cursor).trim().length).toBeGreaterThan(0);
+            }
+        }
+    });
+});

package/dist/main.d.ts

@@ -1 +1,2 @@
 import './index.css';
+import './styles/ui-primitives.css';

package/dist/main.js

@@ -3,31 +3,25 @@ import React from 'react';
 import ReactDOM from 'react-dom/client';
 import { BrowserRouter } from 'react-router-dom';
 import './index.css';
+import './styles/ui-primitives.css';
 import { Taskforce } from './Taskforce';
 import { TaskforceCore } from './TaskforceCore';
+import { resolveClientDeploymentConfig } from './config/clientDeployment';
 const isStandalone = import.meta.env.VITE_STANDALONE === 'true';
-const baseUrl = typeof import.meta.env.VITE_TASKFORCE_BASE_URL === 'string'
-    ? import.meta.env.VITE_TASKFORCE_BASE_URL.trim()
-    : '';
-const apiBaseUrl = typeof import.meta.env.VITE_TASKFORCE_API_BASE_URL === 'string'
-    ? import.meta.env.VITE_TASKFORCE_API_BASE_URL.trim()
-    : '';
-const cloudAuthBaseUrl = typeof import.meta.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL === 'string'
-    ? import.meta.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL.trim()
-    : '';
-const resolvedApiBaseUrl = apiBaseUrl.length > 0 ? apiBaseUrl : (baseUrl.length > 0 ? baseUrl : undefined);
-const resolvedCloudAuthBaseUrl = cloudAuthBaseUrl.length > 0 ? cloudAuthBaseUrl : resolvedApiBaseUrl;
+const deployment = resolveClientDeploymentConfig(import.meta.env);
+const resolvedApiBaseUrl = deployment.apiBaseUrl || undefined;
+const resolvedCloudAuthBaseUrl = deployment.cloudAuthBaseUrl || resolvedApiBaseUrl;
+const resolvedCloudMcpBaseUrl = deployment.cloudMcpBaseUrl || resolvedCloudAuthBaseUrl;
 if (isStandalone) {
     document.title = 'Taskforce';
 }
 ReactDOM.createRoot(document.getElementById('root')).render(_jsx(React.StrictMode, { children: _jsx(BrowserRouter, { children: isStandalone ? (_jsx(TaskforceCore, { mode: "standalone", config: {
                 categories: ['Feature', 'Bug', 'Research'],
-                theme: 'midnight',
-                apiBaseUrl: resolvedApiBaseUrl,
-                cloudAuthBaseUrl: resolvedCloudAuthBaseUrl
+                theme: 'midnight'
             } })) : (_jsx(Taskforce, { config: {
                 categories: ['Feature', 'Bug', 'Research'],
                 theme: 'midnight',
                 apiBaseUrl: resolvedApiBaseUrl,
-                cloudAuthBaseUrl: resolvedCloudAuthBaseUrl
+                cloudAuthBaseUrl: resolvedCloudAuthBaseUrl,
+                cloudMcpBaseUrl: resolvedCloudMcpBaseUrl
             } })) }) }));

package/dist/mcp/clientIntegrations.d.ts

@@ -0,0 +1,33 @@
+export type McpClientId = 'cursor' | 'cline' | 'vscode' | 'windsurf' | 'antigravity' | 'openclaw' | 'codex' | 'claude-code' | 'gemini-cli' | 'claude-desktop' | 'chatgpt-desktop';
+export interface McpClientOption {
+    id: McpClientId;
+    label: string;
+    disabled?: boolean;
+}
+export interface BuildCloudMcpClientConfigInput {
+    clientId: McpClientId;
+    endpoint: string;
+    tokenValue: string;
+    serverId: string;
+    aiProfileName?: string | null;
+    aiProfileToken?: string | null;
+    aiProfileDescription?: string | null;
+    aiProfileRole?: string | null;
+    aiProfileProvider?: string | null;
+    aiProfileModel?: string | null;
+    aiProfileSurfaceType?: string | null;
+}
+export interface CloudMcpClientIntegration {
+    clientId: McpClientId;
+    kind: 'json' | 'text';
+    instructionLabel: string;
+    instructionText: string;
+    rootKey?: 'mcpServers' | 'servers';
+    wrapperKeys?: string[];
+    serverConfig?: unknown;
+    renderedText?: string;
+}
+export declare const MCP_CLIENT_OPTIONS: McpClientOption[];
+export declare function sanitizeMcpId(value: string, fallback: string): string;
+export declare function buildCloudMcpServerId(workspaceName?: string | null, projectName?: string | null): string;
+export declare function buildCloudMcpClientIntegration(input: BuildCloudMcpClientConfigInput): CloudMcpClientIntegration;

package/dist/mcp/clientIntegrations.js

@@ -0,0 +1,199 @@
+export const MCP_CLIENT_OPTIONS = [
+    { id: 'cursor', label: 'Cursor' },
+    { id: 'cline', label: 'Cline' },
+    { id: 'vscode', label: 'VS Code / Copilot' },
+    { id: 'windsurf', label: 'Windsurf' },
+    { id: 'antigravity', label: 'Antigravity' },
+    { id: 'openclaw', label: 'OpenClaw' },
+    { id: 'codex', label: 'Codex' },
+    { id: 'claude-code', label: 'Claude Code CLI' },
+    { id: 'gemini-cli', label: 'Gemini CLI' },
+];
+export function sanitizeMcpId(value, fallback) {
+    const normalized = String(value || '')
+        .toLowerCase()
+        .replace(/[^a-zA-Z0-9_-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^[-_]+|[-_]+$/g, '');
+    return normalized || fallback.toLowerCase();
+}
+export function buildCloudMcpServerId(workspaceName, projectName) {
+    const readableSource = sanitizeMcpId(workspaceName || projectName || 'workspace', 'workspace');
+    const readableName = readableSource.slice(0, 25) || 'workspace';
+    return sanitizeMcpId(`taskforce-${readableName}`, 'taskforce-workspace');
+}
+function buildConnectorDetails(clientId, endpoint) {
+    if (clientId === 'claude-desktop') {
+        return endpoint;
+    }
+    return endpoint;
+}
+function buildCloudMcpHeaders(input) {
+    const headers = {
+        Authorization: `Bearer ${input.tokenValue}`
+    };
+    const aiProfileName = String(input.aiProfileName || '').trim();
+    const aiProfileToken = String(input.aiProfileToken || '').trim();
+    const aiProfileDescription = String(input.aiProfileDescription || '').trim();
+    const aiProfileRole = String(input.aiProfileRole || '').trim();
+    const aiProfileProvider = String(input.aiProfileProvider || '').trim();
+    const aiProfileModel = String(input.aiProfileModel || '').trim();
+    const aiProfileSurfaceType = String(input.aiProfileSurfaceType || '').trim();
+    if (aiProfileName) {
+        headers['X-Taskforce-AI-Name'] = aiProfileName;
+    }
+    if (aiProfileToken) {
+        headers['X-Taskforce-AI-Profile-Token'] = aiProfileToken;
+    }
+    if (aiProfileDescription) {
+        headers['X-Taskforce-AI-Description'] = aiProfileDescription;
+    }
+    if (aiProfileRole) {
+        headers['X-Taskforce-AI-Role'] = aiProfileRole;
+    }
+    if (aiProfileProvider) {
+        headers['X-Taskforce-AI-Provider'] = aiProfileProvider;
+    }
+    if (aiProfileModel) {
+        headers['X-Taskforce-AI-Model'] = aiProfileModel;
+    }
+    if (aiProfileSurfaceType) {
+        headers['X-Taskforce-AI-Surface-Type'] = aiProfileSurfaceType;
+    }
+    return headers;
+}
+export function buildCloudMcpClientIntegration(input) {
+    const { clientId, endpoint, tokenValue, serverId } = input;
+    const headers = buildCloudMcpHeaders(input);
+    const authHeader = headers.Authorization;
+    const extraHeaderFlags = Object.entries(headers)
+        .filter(([key]) => key !== 'Authorization')
+        .map(([key, value]) => ` --header "${key}: ${value}"`)
+        .join('');
+    switch (clientId) {
+        case 'cursor':
+            return {
+                clientId,
+                kind: 'json',
+                rootKey: 'mcpServers',
+                serverConfig: {
+                    url: endpoint,
+                    headers
+                },
+                instructionLabel: 'Cursor Configuration Instructions',
+                instructionText: 'Open Cursor settings, find MCP servers, and paste this config. For automated AI workers, include X-Taskforce-AI-Name and later X-Taskforce-AI-Profile-Token in the headers to let Taskforce bind the same AI profile automatically.'
+            };
+        case 'cline':
+            return {
+                clientId,
+                kind: 'json',
+                rootKey: 'mcpServers',
+                serverConfig: {
+                    url: endpoint,
+                    type: 'streamableHttp',
+                    headers
+                },
+                instructionLabel: 'Cline Configuration Instructions',
+                instructionText: 'Open Cline MCP Servers, add a remote server, or paste this into the Cline MCP config with Streamable HTTP selected. For automated AI workers, include X-Taskforce-AI-Name and later X-Taskforce-AI-Profile-Token in the headers to let Taskforce bind the same AI profile automatically.'
+            };
+        case 'vscode':
+            return {
+                clientId,
+                kind: 'json',
+                rootKey: 'servers',
+                serverConfig: {
+                    type: 'http',
+                    url: endpoint,
+                    headers
+                },
+                instructionLabel: 'VS Code Configuration Instructions',
+                instructionText: 'Open .vscode/mcp.json or MCP: Open User Configuration and add this server under the servers object. For automated AI workers, include X-Taskforce-AI-Name and later X-Taskforce-AI-Profile-Token in the headers to let Taskforce bind the same AI profile automatically.'
+            };
+        case 'windsurf':
+            return {
+                clientId,
+                kind: 'json',
+                rootKey: 'mcpServers',
+                serverConfig: {
+                    serverUrl: endpoint,
+                    headers
+                },
+                instructionLabel: 'Windsurf Configuration Instructions',
+                instructionText: 'Open Windsurf MCP settings, add a server, and paste this config. For automated AI workers, include X-Taskforce-AI-Name and later X-Taskforce-AI-Profile-Token in the headers to let Taskforce bind the same AI profile automatically.'
+            };
+        case 'antigravity':
+            return {
+                clientId,
+                kind: 'json',
+                rootKey: 'mcpServers',
+                serverConfig: {
+                    serverUrl: endpoint,
+                    headers
+                },
+                instructionLabel: 'Antigravity Configuration Instructions',
+                instructionText: 'Open Antigravity MCP settings, view the raw config, and paste this Antigravity-specific configuration. For automated AI workers, include X-Taskforce-AI-Name and later X-Taskforce-AI-Profile-Token in the headers to let Taskforce bind the same AI profile automatically.'
+            };
+        case 'openclaw':
+            return {
+                clientId,
+                kind: 'json',
+                rootKey: 'servers',
+                wrapperKeys: ['mcp'],
+                serverConfig: {
+                    transport: 'streamable-http',
+                    url: endpoint,
+                    headers
+                },
+                instructionLabel: 'OpenClaw Configuration Instructions',
+                instructionText: 'Open ~/.openclaw/openclaw.json and add this server under mcp.servers. For automated AI workers, include X-Taskforce-AI-Name and later X-Taskforce-AI-Profile-Token in the headers to let Taskforce bind the same AI profile automatically.'
+            };
+        case 'codex':
+            return {
+                clientId,
+                kind: 'text',
+                renderedText: [
+                    `[mcp_servers.${serverId}]`,
+                    `url = "${endpoint}"`,
+                    `http_headers = { ${Object.entries(headers).map(([key, value]) => `${key} = "${value}"`).join(', ')} }`
+                ].join('\n'),
+                instructionLabel: 'Codex Configuration Instructions',
+                instructionText: 'Open ~/.codex/config.toml and add this Codex MCP entry. For automated AI workers, set X-Taskforce-AI-Name and later X-Taskforce-AI-Profile-Token here so Taskforce binds the same AI profile automatically.'
+            };
+        case 'claude-code':
+            return {
+                clientId,
+                kind: 'text',
+                renderedText: `claude mcp add --transport http ${serverId} ${endpoint} --header "Authorization: Bearer ${tokenValue}"${extraHeaderFlags}`,
+                instructionLabel: 'Claude Code Configuration Instructions',
+                instructionText: 'Run this Claude Code command in your terminal to add the remote Taskforce MCP server. For automated AI workers, keep the X-Taskforce-AI-Name header and later add X-Taskforce-AI-Profile-Token so Taskforce binds the same AI profile automatically.'
+            };
+        case 'gemini-cli':
+            return {
+                clientId,
+                kind: 'text',
+                renderedText: `gemini mcp add ${serverId} ${endpoint} --transport http --header "Authorization: Bearer ${tokenValue}"${extraHeaderFlags}`,
+                instructionLabel: 'Gemini CLI Configuration Instructions',
+                instructionText: 'Run this Gemini CLI command in your terminal to add the remote Taskforce MCP server. Add --scope user if you want it available across all projects. For automated AI workers, keep the X-Taskforce-AI-Name header and later add X-Taskforce-AI-Profile-Token so Taskforce binds the same AI profile automatically.'
+            };
+        case 'claude-desktop':
+            return {
+                clientId,
+                kind: 'text',
+                renderedText: buildConnectorDetails(clientId, endpoint),
+                instructionLabel: 'Claude Desktop Configuration Instructions',
+                instructionText: 'Open Claude Desktop Settings > Connectors, paste this MCP server URL, and complete the Taskforce OAuth flow to authorize one workspace.'
+            };
+        case 'chatgpt-desktop':
+            return {
+                clientId,
+                kind: 'text',
+                renderedText: endpoint,
+                instructionLabel: 'ChatGPT Desktop Configuration Instructions',
+                instructionText: 'Open ChatGPT Apps & Connectors / developer mode, paste this MCP server URL, and complete the Taskforce OAuth authorize flow when ChatGPT opens it.'
+            };
+        default: {
+            const exhaustiveCheck = clientId;
+            throw new Error(`Unsupported MCP client: ${exhaustiveCheck}`);
+        }
+    }
+}

package/dist/mcp/clientIntegrations.test.d.ts

@@ -0,0 +1 @@
+export {};