@taskforcehq/taskforce 0.3.301 → 0.3.302

package/dist/hooks/useTaskforce.sync-behavior.test.js

@@ -87,6 +87,7 @@ const archivedTaskRecord = (id, title) => ({
 describe('useTaskforce sync behavior', () => {
     beforeEach(() => {
         localStorage.clear();
+        sessionStorage.clear();
     });
     afterEach(() => {
         vi.useRealTimers();
@@ -97,7 +98,7 @@ describe('useTaskforce sync behavior', () => {
     it('merges a server-returned task into the active collection immediately', async () => {
         vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } });
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
             if (url.includes('/api/taskforce/auth/session')) {
                 return jsonResponse({
@@ -188,7 +189,7 @@ describe('useTaskforce sync behavior', () => {
     it('keeps the dawn theme when settings re-fetch configuration', async () => {
         const fetchMock = vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } });
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
             if (url.includes('/api/taskforce/auth/session')) {
                 return jsonResponse({
@@ -261,7 +262,7 @@ describe('useTaskforce sync behavior', () => {
     it('merges a server-returned archived task immediately instead of dropping it between collections', async () => {
         vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } });
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
             if (url.includes('/api/taskforce/ui-state?key=app')) {
                 return jsonResponse({ success: true, state: {} });
@@ -339,7 +340,7 @@ describe('useTaskforce sync behavior', () => {
     it('merges a server-returned completed task immediately when toggling done', async () => {
         vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } });
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
             if (url.includes('/api/taskforce/ui-state?key=app')) {
                 return jsonResponse({ success: true, state: {} });
@@ -416,7 +417,7 @@ describe('useTaskforce sync behavior', () => {
         vi.stubGlobal('confirm', vi.fn(() => true));
         vi.stubGlobal('fetch', vi.fn((url, init) => {
             if (url.includes('/api/taskforce/auth/runtime-config')) {
-                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'local' } });
+                return jsonResponse({ config: { runtimeMode: 'local', workspaceMode: 'single-local', authSource: 'cloud' } });
             }
             if (url.includes('/api/taskforce/ui-state?key=app')) {
                 return jsonResponse({ success: true, state: {} });
@@ -503,7 +504,7 @@ describe('useTaskforce sync behavior', () => {
                     config: {
                         runtimeMode: 'local',
                         workspaceMode: 'single-local',
-                        authSource: 'local',
+                        authSource: 'cloud',
                         baseUrl: 'http://localhost:5174',
                         apiBaseUrl: 'http://localhost:5174',
                         cloudAuthBaseUrl: 'http://localhost:5174'
@@ -918,6 +919,184 @@ describe('useTaskforce sync behavior', () => {
             expect(result.current.assigneeOptions.some((option) => option.value === 'ai-profile-codex' && option.label === 'Codex')).toBe(true);
         });
     });
+    it('keeps the local hydrated workspace role when workspace-members temporarily fails', async () => {
+        let workspaceMembersCalls = 0;
+        vi.stubGlobal('fetch', vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'local',
+                        workspaceMode: 'single-local',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: false
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Local Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'local',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/approaches'))
+                return jsonResponse({ approaches: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options')) {
+                return jsonResponse({
+                    assignees: [
+                        { value: 'member-1', label: 'Member One', icon: 'User', color: '#22c55e', kind: 'member', userId: 'member-1', email: 'member1@example.com' }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/auth/workspace-members')) {
+                workspaceMembersCalls += 1;
+                if (workspaceMembersCalls === 1) {
+                    return jsonResponse({
+                        users: [
+                            {
+                                userId: 'user-1',
+                                email: 'user@example.com',
+                                displayName: 'Signed In Owner',
+                                role: 'owner',
+                                status: 'active',
+                                disabled: false
+                            }
+                        ]
+                    });
+                }
+                return Promise.reject(new Error('temporary workspace-members failure'));
+            }
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.currentWorkspaceRole).toBe('owner');
+        });
+        await act(async () => {
+            await result.current.fetchAssigneeOptions();
+        });
+        expect(result.current.currentWorkspaceRole).toBe('owner');
+    });
+    it('seeds local auth state from the persisted loopback actor while localhost session bootstrap is in flight', async () => {
+        sessionStorage.setItem('taskforce.localMutationActorUserId.v1', 'user-1');
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'local',
+                        workspaceMode: 'single-local',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: false,
+                        cloudAuthBaseUrl: 'https://app.taskforcehq.ai',
+                        cloudAuthViaLocalProxy: true
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Local Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'local',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/approaches'))
+                return jsonResponse({ approaches: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://app.taskforcehq.ai' } }), { wrapper });
+        expect(result.current.isAuthenticated).toBe(true);
+        expect(result.current.authSessionResolved).toBe(true);
+        await waitFor(() => {
+            expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/api/taskforce/auth/session'))).toBe(true);
+        });
+        await waitFor(() => {
+            expect(result.current.isAuthenticated).toBe(true);
+            expect(result.current.authSessionResolved).toBe(true);
+        });
+    });
     it('enables cloud realtime refresh for authenticated sessions and refreshes open task comments from signals', async () => {
         vi.stubGlobal('WebSocket', MockWebSocket);
         let invalidationTaskFetchCount = 0;

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 {