@taskforcehq/taskforce 0.3.301 → 0.3.303

package/dist/mcp/aiProfileBootstrap.d.ts

@@ -0,0 +1,29 @@
+import type { IncomingHttpHeaders } from 'http';
+import type { ResolveAiProfileInput } from '../core/Taskforce.js';
+import { type AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+export interface AiProfileBootstrapConfig {
+    aiProfileToken?: string | null;
+    aiProfileName?: string | null;
+    aiProfileIcon?: string | null;
+    aiProfileColor?: string | null;
+    aiProfileDescription?: string | null;
+    aiProfileRole?: string | null;
+    aiProfileProvider?: string | null;
+    aiProfileModel?: string | null;
+    aiProfileSurfaceType?: AiProfileSurfaceType | null;
+}
+export declare const AI_PROFILE_BOOTSTRAP_HEADER_NAMES: {
+    readonly aiProfileToken: "X-Taskforce-AI-Profile-Token";
+    readonly aiProfileName: "X-Taskforce-AI-Name";
+    readonly aiProfileIcon: "X-Taskforce-AI-Icon";
+    readonly aiProfileColor: "X-Taskforce-AI-Color";
+    readonly aiProfileDescription: "X-Taskforce-AI-Description";
+    readonly aiProfileRole: "X-Taskforce-AI-Role";
+    readonly aiProfileProvider: "X-Taskforce-AI-Provider";
+    readonly aiProfileModel: "X-Taskforce-AI-Model";
+    readonly aiProfileSurfaceType: "X-Taskforce-AI-Surface-Type";
+};
+export declare function normalizeAiProfileBootstrapConfig(input: AiProfileBootstrapConfig): AiProfileBootstrapConfig;
+export declare function buildAiProfileBootstrapHeaders(input: AiProfileBootstrapConfig): Record<string, string>;
+export declare function parseAiProfileBootstrapHeaders(headers: IncomingHttpHeaders | Record<string, string | string[] | undefined>): Required<AiProfileBootstrapConfig>;
+export declare function buildResolveAiProfileInputFromBootstrap(workspaceId: string, bootstrap: AiProfileBootstrapConfig, includeToken?: boolean): Pick<ResolveAiProfileInput, 'workspaceId' | 'name' | 'profileToken' | 'icon' | 'color' | 'description' | 'role' | 'provider' | 'model' | 'surfaceType'> | null;

package/dist/mcp/aiProfileBootstrap.js

@@ -0,0 +1,80 @@
+import { parseAiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+export const AI_PROFILE_BOOTSTRAP_HEADER_NAMES = {
+    aiProfileToken: 'X-Taskforce-AI-Profile-Token',
+    aiProfileName: 'X-Taskforce-AI-Name',
+    aiProfileIcon: 'X-Taskforce-AI-Icon',
+    aiProfileColor: 'X-Taskforce-AI-Color',
+    aiProfileDescription: 'X-Taskforce-AI-Description',
+    aiProfileRole: 'X-Taskforce-AI-Role',
+    aiProfileProvider: 'X-Taskforce-AI-Provider',
+    aiProfileModel: 'X-Taskforce-AI-Model',
+    aiProfileSurfaceType: 'X-Taskforce-AI-Surface-Type',
+};
+function normalizeBootstrapValue(value) {
+    const normalized = String(value || '').trim();
+    return normalized || null;
+}
+function normalizeBootstrapSurfaceType(value) {
+    if (value === null || value === undefined)
+        return null;
+    return parseAiProfileSurfaceType(value);
+}
+export function normalizeAiProfileBootstrapConfig(input) {
+    return {
+        aiProfileToken: normalizeBootstrapValue(input.aiProfileToken),
+        aiProfileName: normalizeBootstrapValue(input.aiProfileName),
+        aiProfileIcon: normalizeBootstrapValue(input.aiProfileIcon),
+        aiProfileColor: normalizeBootstrapValue(input.aiProfileColor),
+        aiProfileDescription: normalizeBootstrapValue(input.aiProfileDescription),
+        aiProfileRole: normalizeBootstrapValue(input.aiProfileRole),
+        aiProfileProvider: normalizeBootstrapValue(input.aiProfileProvider),
+        aiProfileModel: normalizeBootstrapValue(input.aiProfileModel),
+        aiProfileSurfaceType: normalizeBootstrapSurfaceType(input.aiProfileSurfaceType),
+    };
+}
+export function buildAiProfileBootstrapHeaders(input) {
+    const normalized = normalizeAiProfileBootstrapConfig(input);
+    const headers = {};
+    for (const [key, headerName] of Object.entries(AI_PROFILE_BOOTSTRAP_HEADER_NAMES)) {
+        const value = normalized[key];
+        if (value)
+            headers[headerName] = value;
+    }
+    return headers;
+}
+export function parseAiProfileBootstrapHeaders(headers) {
+    const readHeader = (headerName) => {
+        const value = headers[headerName] ?? headers[headerName.toLowerCase()];
+        if (Array.isArray(value))
+            return normalizeBootstrapValue(value[0]);
+        return normalizeBootstrapValue(value);
+    };
+    return {
+        aiProfileToken: readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileToken),
+        aiProfileName: readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileName),
+        aiProfileIcon: readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileIcon),
+        aiProfileColor: readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileColor),
+        aiProfileDescription: readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileDescription),
+        aiProfileRole: readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileRole),
+        aiProfileProvider: readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileProvider),
+        aiProfileModel: readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileModel),
+        aiProfileSurfaceType: normalizeBootstrapSurfaceType(readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileSurfaceType)),
+    };
+}
+export function buildResolveAiProfileInputFromBootstrap(workspaceId, bootstrap, includeToken = true) {
+    const normalized = normalizeAiProfileBootstrapConfig(bootstrap);
+    if (!normalized.aiProfileName)
+        return null;
+    return {
+        workspaceId,
+        name: normalized.aiProfileName,
+        ...(includeToken && normalized.aiProfileToken ? { profileToken: normalized.aiProfileToken } : {}),
+        ...(normalized.aiProfileIcon ? { icon: normalized.aiProfileIcon } : {}),
+        ...(normalized.aiProfileColor ? { color: normalized.aiProfileColor } : {}),
+        ...(normalized.aiProfileDescription ? { description: normalized.aiProfileDescription } : {}),
+        ...(normalized.aiProfileRole ? { role: normalized.aiProfileRole } : {}),
+        ...(normalized.aiProfileProvider ? { provider: normalized.aiProfileProvider } : {}),
+        ...(normalized.aiProfileModel ? { model: normalized.aiProfileModel } : {}),
+        ...(normalized.aiProfileSurfaceType ? { surfaceType: normalized.aiProfileSurfaceType } : {}),
+    };
+}

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

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

package/dist/mcp/aiProfileBootstrap.test.js

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import { AI_PROFILE_BOOTSTRAP_HEADER_NAMES, buildAiProfileBootstrapHeaders, buildResolveAiProfileInputFromBootstrap, parseAiProfileBootstrapHeaders, } from './aiProfileBootstrap';
+describe('aiProfileBootstrap', () => {
+    it('builds and parses bootstrap headers from a shared contract', () => {
+        const headers = buildAiProfileBootstrapHeaders({
+            aiProfileName: 'Automation Codex',
+            aiProfileToken: 'tfp_automation_codex',
+            aiProfileIcon: 'Code2',
+            aiProfileColor: '#10a37f',
+            aiProfileDescription: 'OpenAI Codex coding agent connected through MCP.',
+            aiProfileRole: 'Coding Agent',
+            aiProfileProvider: 'OpenAI',
+            aiProfileModel: 'Codex',
+            aiProfileSurfaceType: 'coding_tool',
+        });
+        expect(headers).toEqual({
+            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileName]: 'Automation Codex',
+            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileToken]: 'tfp_automation_codex',
+            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileIcon]: 'Code2',
+            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileColor]: '#10a37f',
+            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileDescription]: 'OpenAI Codex coding agent connected through MCP.',
+            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileRole]: 'Coding Agent',
+            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileProvider]: 'OpenAI',
+            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileModel]: 'Codex',
+            [AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileSurfaceType]: 'coding_tool',
+        });
+        expect(parseAiProfileBootstrapHeaders(headers)).toEqual({
+            aiProfileName: 'Automation Codex',
+            aiProfileToken: 'tfp_automation_codex',
+            aiProfileIcon: 'Code2',
+            aiProfileColor: '#10a37f',
+            aiProfileDescription: 'OpenAI Codex coding agent connected through MCP.',
+            aiProfileRole: 'Coding Agent',
+            aiProfileProvider: 'OpenAI',
+            aiProfileModel: 'Codex',
+            aiProfileSurfaceType: 'coding_tool',
+        });
+    });
+    it('builds resolve_profile input from bootstrap metadata', () => {
+        expect(buildResolveAiProfileInputFromBootstrap('workspace-1', {
+            aiProfileName: 'Automation Codex',
+            aiProfileToken: 'tfp_automation_codex',
+            aiProfileIcon: 'Code2',
+            aiProfileColor: '#10a37f',
+            aiProfileDescription: 'OpenAI Codex coding agent connected through MCP.',
+            aiProfileRole: 'Coding Agent',
+            aiProfileProvider: 'OpenAI',
+            aiProfileModel: 'Codex',
+            aiProfileSurfaceType: 'coding_tool',
+        })).toEqual({
+            workspaceId: 'workspace-1',
+            name: 'Automation Codex',
+            profileToken: 'tfp_automation_codex',
+            icon: 'Code2',
+            color: '#10a37f',
+            description: 'OpenAI Codex coding agent connected through MCP.',
+            role: 'Coding Agent',
+            provider: 'OpenAI',
+            model: 'Codex',
+            surfaceType: 'coding_tool',
+        });
+    });
+    it('returns null resolve input when no bootstrap name is present', () => {
+        expect(buildResolveAiProfileInputFromBootstrap('workspace-1', {
+            aiProfileToken: 'tfp_automation_codex',
+        })).toBeNull();
+    });
+});

package/dist/mcp/clientIntegrations.d.ts

@@ -1,21 +1,15 @@
+import { type AiProfileBootstrapConfig } from './aiProfileBootstrap.js';
 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 {
+export interface BuildCloudMcpClientConfigInput extends AiProfileBootstrapConfig {
     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;

package/dist/mcp/clientIntegrations.js

@@ -1,3 +1,4 @@
+import { buildAiProfileBootstrapHeaders } from './aiProfileBootstrap.js';
 export const MCP_CLIENT_OPTIONS = [
     { id: 'cursor', label: 'Cursor' },
     { id: 'cline', label: 'Cline' },
@@ -29,38 +30,18 @@ function buildConnectorDetails(clientId, endpoint) {
     return endpoint;
 }
 function buildCloudMcpHeaders(input) {
-    const headers = {
-        Authorization: `Bearer ${input.tokenValue}`
+    return {
+        Authorization: `Bearer ${input.tokenValue}`,
+        ...buildAiProfileBootstrapHeaders(input),
     };
-    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;
+}
+function buildAutomationBootstrapInstruction(baseInstruction) {
+    return `${baseInstruction} Keep the generated AI bootstrap headers intact so Taskforce can bind and restore the same AI profile automatically.`;
+}
+function buildConfigurationInstruction(baseInstruction, options) {
+    if (options?.usesGeneratedConfig === false)
+        return baseInstruction;
+    return buildAutomationBootstrapInstruction(`${baseInstruction} Use the generated config exactly as shown.`);
 }
 export function buildCloudMcpClientIntegration(input) {
     const { clientId, endpoint, tokenValue, serverId } = input;
@@ -81,7 +62,7 @@ export function buildCloudMcpClientIntegration(input) {
                     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.'
+                instructionText: buildConfigurationInstruction('Open Cursor settings, find MCP servers, and paste this config.')
             };
         case 'cline':
             return {
@@ -94,7 +75,7 @@ export function buildCloudMcpClientIntegration(input) {
                     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.'
+                instructionText: buildConfigurationInstruction('Open Cline MCP Servers, add a remote server, or paste this into the Cline MCP config with Streamable HTTP selected.')
             };
         case 'vscode':
             return {
@@ -107,7 +88,7 @@ export function buildCloudMcpClientIntegration(input) {
                     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.'
+                instructionText: buildConfigurationInstruction('Open .vscode/mcp.json or MCP: Open User Configuration and add this server under the servers object.')
             };
         case 'windsurf':
             return {
@@ -119,7 +100,7 @@ export function buildCloudMcpClientIntegration(input) {
                     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.'
+                instructionText: buildConfigurationInstruction('Open Windsurf MCP settings, add a server, and paste this config.')
             };
         case 'antigravity':
             return {
@@ -131,7 +112,7 @@ export function buildCloudMcpClientIntegration(input) {
                     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.'
+                instructionText: buildConfigurationInstruction('Open Antigravity MCP settings, view the raw config, and paste this Antigravity-specific configuration.')
             };
         case 'openclaw':
             return {
@@ -145,7 +126,7 @@ export function buildCloudMcpClientIntegration(input) {
                     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.'
+                instructionText: buildConfigurationInstruction('Open ~/.openclaw/openclaw.json and add this server under mcp.servers.')
             };
         case 'codex':
             return {
@@ -157,7 +138,7 @@ export function buildCloudMcpClientIntegration(input) {
                     `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.'
+                instructionText: buildConfigurationInstruction('Open ~/.codex/config.toml and add this Codex MCP entry.')
             };
         case 'claude-code':
             return {
@@ -165,7 +146,7 @@ export function buildCloudMcpClientIntegration(input) {
                 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.'
+                instructionText: buildConfigurationInstruction('Run this Claude Code command in your terminal to add the remote Taskforce MCP server.')
             };
         case 'gemini-cli':
             return {
@@ -173,7 +154,7 @@ export function buildCloudMcpClientIntegration(input) {
                 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.'
+                instructionText: buildConfigurationInstruction('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.')
             };
         case 'claude-desktop':
             return {

package/dist/mcp/clientIntegrations.test.js

@@ -45,6 +45,8 @@ describe('clientIntegrations', () => {
             serverId: 'taskforce-workspace-alpha',
             aiProfileName: 'Automation Codex',
             aiProfileToken: 'tfp_automation_codex',
+            aiProfileIcon: 'Code2',
+            aiProfileColor: '#10a37f',
             aiProfileDescription: 'OpenAI Codex coding agent connected through MCP.',
             aiProfileRole: 'Coding Agent',
             aiProfileProvider: 'OpenAI',
@@ -57,26 +59,34 @@ describe('clientIntegrations', () => {
             tokenValue: '<<GENERATE_TOKEN>>',
             serverId: 'taskforce-workspace-alpha',
             aiProfileName: 'Automation Codex',
+            aiProfileIcon: 'Code2',
+            aiProfileColor: '#10a37f',
             aiProfileRole: 'Coding Agent',
         });
         expect(codex.renderedText).toContain('X-Taskforce-AI-Name = "Automation Codex"');
         expect(codex.renderedText).toContain('X-Taskforce-AI-Profile-Token = "tfp_automation_codex"');
+        expect(codex.renderedText).toContain('X-Taskforce-AI-Icon = "Code2"');
+        expect(codex.renderedText).toContain('X-Taskforce-AI-Color = "#10a37f"');
         expect(codex.renderedText).toContain('X-Taskforce-AI-Description = "OpenAI Codex coding agent connected through MCP."');
         expect(codex.renderedText).toContain('X-Taskforce-AI-Role = "Coding Agent"');
         expect(codex.renderedText).toContain('X-Taskforce-AI-Provider = "OpenAI"');
         expect(codex.renderedText).toContain('X-Taskforce-AI-Model = "Codex"');
         expect(codex.renderedText).toContain('X-Taskforce-AI-Surface-Type = "coding_tool"');
-        expect(codex.instructionText).toContain('automated AI workers');
+        expect(codex.instructionText).toContain('Use the generated config exactly as shown.');
+        expect(codex.instructionText).toContain('generated AI bootstrap headers');
         expect(vscode.serverConfig).toEqual({
             type: 'http',
             url: 'https://performance-app.taskforcehq.ai/mcp',
             headers: {
                 Authorization: 'Bearer <<GENERATE_TOKEN>>',
                 'X-Taskforce-AI-Name': 'Automation Codex',
+                'X-Taskforce-AI-Icon': 'Code2',
+                'X-Taskforce-AI-Color': '#10a37f',
                 'X-Taskforce-AI-Role': 'Coding Agent',
             }
         });
-        expect(vscode.instructionText).toContain('automated AI workers');
+        expect(vscode.instructionText).toContain('Use the generated config exactly as shown.');
+        expect(vscode.instructionText).toContain('generated AI bootstrap headers');
     });
     it('builds JSON text config for OpenClaw using mcp.servers', () => {
         const integration = buildCloudMcpClientIntegration({
@@ -97,6 +107,22 @@ describe('clientIntegrations', () => {
         });
         expect(integration.instructionText).toContain('~/.openclaw/openclaw.json');
     });
+    it('keeps OAuth connector instructions focused on the URL flow instead of generated config language', () => {
+        const claudeDesktop = buildCloudMcpClientIntegration({
+            clientId: 'claude-desktop',
+            endpoint: 'https://performance-app.taskforcehq.ai/mcp',
+            tokenValue: '<<GENERATE_TOKEN>>',
+            serverId: 'taskforce-workspace-alpha',
+        });
+        const chatgptDesktop = buildCloudMcpClientIntegration({
+            clientId: 'chatgpt-desktop',
+            endpoint: 'https://performance-app.taskforcehq.ai/mcp',
+            tokenValue: '<<GENERATE_TOKEN>>',
+            serverId: 'taskforce-workspace-alpha',
+        });
+        expect(claudeDesktop.instructionText).not.toContain('generated config exactly as shown');
+        expect(chatgptDesktop.instructionText).not.toContain('generated config exactly as shown');
+    });
     it('builds command config for Gemini CLI using http transport', () => {
         const integration = buildCloudMcpClientIntegration({
             clientId: 'gemini-cli',

package/dist/mcp/clientProfileDefaults.d.ts

@@ -0,0 +1,12 @@
+import type { McpClientId } from './clientIntegrations.js';
+import type { AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+export interface AiProfileMetadataDefaults {
+    icon: string | null;
+    color: string | null;
+    description: string | null;
+    role: string | null;
+    provider: string | null;
+    model: string | null;
+    surfaceType: AiProfileSurfaceType | null;
+}
+export declare function getDefaultAiProfileMetadataForClient(clientId: McpClientId): AiProfileMetadataDefaults;

package/dist/mcp/clientProfileDefaults.js

@@ -0,0 +1,37 @@
+const CLIENT_LABELS = {
+    cline: 'Cline',
+    windsurf: 'Windsurf',
+    antigravity: 'Antigravity',
+    openclaw: 'OpenClaw',
+};
+export function getDefaultAiProfileMetadataForClient(clientId) {
+    switch (clientId) {
+        case 'codex':
+            return { icon: 'Code2', color: '#10a37f', description: 'OpenAI Codex coding agent connected through MCP.', role: 'Coding Agent', provider: 'OpenAI', model: 'Codex', surfaceType: 'coding_tool' };
+        case 'chatgpt-desktop':
+            return { icon: 'MessageSquare', color: '#10a37f', description: 'ChatGPT desktop app connected through the Taskforce MCP connector.', role: 'AI Assistant', provider: 'OpenAI', model: 'ChatGPT', surfaceType: 'chat_app' };
+        case 'claude-code':
+            return { icon: 'Sparkles', color: '#d97706', description: 'Claude Code coding agent connected through MCP.', role: 'Coding Agent', provider: 'Anthropic', model: 'Claude Code', surfaceType: 'coding_tool' };
+        case 'claude-desktop':
+            return { icon: 'MessageSquareMore', color: '#d97706', description: 'Claude Desktop connected through the Taskforce MCP connector.', role: 'AI Assistant', provider: 'Anthropic', model: 'Claude', surfaceType: 'chat_app' };
+        case 'gemini-cli':
+            return { icon: 'Gem', color: '#2563eb', description: 'Gemini CLI coding agent connected through MCP.', role: 'Coding Agent', provider: 'Google', model: 'Gemini', surfaceType: 'coding_tool' };
+        case 'vscode':
+            return { icon: 'Code2', color: '#2563eb', description: 'VS Code MCP-connected coding agent.', role: 'Coding Agent', provider: null, model: null, surfaceType: 'ide' };
+        case 'cline':
+        case 'windsurf':
+        case 'antigravity':
+        case 'openclaw':
+            return {
+                icon: 'Bot',
+                color: '#8b5cf6',
+                description: `${CLIENT_LABELS[clientId] || 'MCP'} coding agent connected through MCP.`,
+                role: 'Coding Agent',
+                provider: null,
+                model: null,
+                surfaceType: 'coding_tool',
+            };
+        default:
+            return { icon: null, color: null, description: null, role: null, provider: null, model: null, surfaceType: null };
+    }
+}

package/dist/mcp/runtime.d.ts

@@ -1,6 +1,7 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { McpAccessTokenScope, TaskforceCore } from '../core/Taskforce.js';
+import { type AiProfileBootstrapConfig } from './aiProfileBootstrap.js';
 export interface TaskforceMcpServerOptions {
     projectRoot?: string;
     tenantId?: string;
@@ -13,13 +14,15 @@ export interface TaskforceMcpServerOptions {
         scopes?: McpAccessTokenScope[] | null;
         userId?: string | null;
         tokenId?: string | null;
-        aiProfileToken?: string | null;
-        aiProfileName?: string | null;
-        aiProfileDescription?: string | null;
-        aiProfileRole?: string | null;
-        aiProfileProvider?: string | null;
-        aiProfileModel?: string | null;
-        aiProfileSurfaceType?: string | null;
+        aiProfileToken?: AiProfileBootstrapConfig['aiProfileToken'];
+        aiProfileName?: AiProfileBootstrapConfig['aiProfileName'];
+        aiProfileIcon?: AiProfileBootstrapConfig['aiProfileIcon'];
+        aiProfileColor?: AiProfileBootstrapConfig['aiProfileColor'];
+        aiProfileDescription?: AiProfileBootstrapConfig['aiProfileDescription'];
+        aiProfileRole?: AiProfileBootstrapConfig['aiProfileRole'];
+        aiProfileProvider?: AiProfileBootstrapConfig['aiProfileProvider'];
+        aiProfileModel?: AiProfileBootstrapConfig['aiProfileModel'];
+        aiProfileSurfaceType?: AiProfileBootstrapConfig['aiProfileSurfaceType'];
         actorType?: 'local' | 'user' | 'token' | 'oauth';
         requestId?: string | null;
         ip?: string | null;