@taskforcehq/taskforce 0.3.323 → 0.3.326

package/dist/core/Taskforce.js

@@ -5422,6 +5422,27 @@ export class TaskforceCore {
         `).run(enabled ? 1 : 0, new Date().toISOString(), this.tenantId, normalizedUserId);
         return Number(result?.changes || 0) > 0;
     }
+    markUserEmailVerified(userId) {
+        const normalizedUserId = String(userId || '').trim();
+        if (!normalizedUserId)
+            return null;
+        const now = new Date().toISOString();
+        const row = this.db.prepare(`
+            SELECT id, email_verified_at
+            FROM users
+            WHERE tenant_id = ? AND id = ?
+            LIMIT 1
+        `).get(this.tenantId, normalizedUserId);
+        if (!row?.id)
+            return null;
+        const emailVerifiedAt = row.email_verified_at || now;
+        this.db.prepare(`
+            UPDATE users
+            SET email_verified_at = COALESCE(email_verified_at, ?), updated_at = ?
+            WHERE tenant_id = ? AND id = ?
+        `).run(now, now, this.tenantId, normalizedUserId);
+        return { emailVerifiedAt };
+    }
     purgeSystemUser(input) {
         const targetUserId = String(input.targetUserId || '').trim();
         const actorUserId = String(input.actorUserId || '').trim();

package/dist/hooks/useTaskforce.js

@@ -62,7 +62,7 @@ import { useTaskFilters } from './tasks/useTaskFilters';
 import { useTaskFormActions } from './tasks/useTaskFormActions';
 import { useTaskRelationships } from './tasks/useTaskRelationships';
 import { useTaskActions } from './tasks/useTaskActions';
-import { clearPersistedWorkspaceId, logBootstrapDebug, persistRemoteUiState, readPersistedAppUiState, readPersistedWorkspaceId, writePersistedAppUiState, writePersistedWorkspaceId } from './workspace/workspaceLocalState';
+import { areFilterTaxonomySignaturesEqual, buildFilterTaxonomySignature, clearPersistedWorkspaceId, logBootstrapDebug, persistRemoteUiState, readPersistedAppUiState, readPersistedWorkspaceId, writePersistedAppUiState, writePersistedWorkspaceId } from './workspace/workspaceLocalState';
 import { useTaskforceApiRouting } from './workspace/useTaskforceApiRouting';
 import { useTaskforceAuthBootstrap } from './auth/useTaskforceAuthBootstrap';
 import { deriveAuthGuardPolicy } from './auth/useAuthGuardPolicy';
@@ -442,6 +442,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
     const authSessionLastCheckedAtRef = useRef(0);
     const authSessionLastResultRef = useRef(hasOptimisticLocalAuth);
     const currentWorkspaceIdRef = useRef(currentWorkspaceId);
+    const pendingPersistedTaxonomyUiStateRef = useRef(null);
     const explicitWorkspaceSelectionRef = useRef(null);
     const workspaceTransitionEpochRef = useRef(0);
     const bootstrapTraceSeedRef = useRef((() => {
@@ -1238,9 +1239,26 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         authRequiredForApiRef.current = authRequiredForApi;
         isAuthenticatedRef.current = isAuthenticated;
     }, [authSessionResolved, authRequiredForApi, isAuthenticated]);
+    const currentFilterTaxonomySignature = useMemo(() => (referenceDataLoaded
+        ? buildFilterTaxonomySignature({
+            categories: activeCategories,
+            types: activeTypes,
+            priorities,
+            taxonomies
+        })
+        : null), [activeCategories, activeTypes, priorities, referenceDataLoaded, taxonomies]);
     const applyPersistedUiState = useCallback((state, options) => {
-        if (!state)
+        if (!state) {
+            pendingPersistedTaxonomyUiStateRef.current = null;
             return;
+        }
+        const hasPersistedTaxonomyFilterState = Array.isArray(state.filterCategories)
+            || Array.isArray(state.filterPriorities)
+            || Array.isArray(state.filterTypes)
+            || (state.filterTaxonomies && typeof state.filterTaxonomies === 'object');
+        if (!hasPersistedTaxonomyFilterState) {
+            pendingPersistedTaxonomyUiStateRef.current = null;
+        }
         const hasPersistedFilterState = Array.isArray(state.filterCategories)
             || Array.isArray(state.filterPriorities)
             || Array.isArray(state.filterTypes)
@@ -1248,6 +1266,20 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             || Array.isArray(state.filterAssignees)
             || typeof state.filterAssigneesAllSelected === 'boolean'
             || (state.filterTaxonomies && typeof state.filterTaxonomies === 'object');
+        const canCompareTaxonomySignature = currentFilterTaxonomySignature !== null;
+        if (hasPersistedTaxonomyFilterState && !canCompareTaxonomySignature) {
+            pendingPersistedTaxonomyUiStateRef.current = {
+                state,
+                skipActiveWorkspaceModule: options?.skipActiveWorkspaceModule
+            };
+        }
+        const canApplyTaxonomyFilters = hasPersistedTaxonomyFilterState
+            && canCompareTaxonomySignature
+            && areFilterTaxonomySignaturesEqual(state.filterTaxonomySignature, currentFilterTaxonomySignature);
+        const shouldResetTaxonomyFilters = hasPersistedTaxonomyFilterState
+            && canCompareTaxonomySignature
+            && !canApplyTaxonomyFilters;
+        const taxonomyFiltersAreReady = !hasPersistedTaxonomyFilterState || canApplyTaxonomyFilters || shouldResetTaxonomyFilters;
         if (!options?.skipActiveWorkspaceModule) {
             if (typeof state.activeWorkspaceModule === 'string') {
                 setActiveWorkspaceModuleState(state.activeWorkspaceModule);
@@ -1264,28 +1296,39 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             setZenModeState(state.zenMode);
         if (typeof state.searchQuery === 'string')
             setSearchQuery(state.searchQuery);
-        if (Array.isArray(state.filterCategories))
-            setFilterCategories(state.filterCategories);
-        if (Array.isArray(state.filterPriorities))
-            setFilterPriorities(state.filterPriorities);
-        if (Array.isArray(state.filterTypes))
-            setFilterTypes(state.filterTypes);
+        if (canApplyTaxonomyFilters) {
+            if (Array.isArray(state.filterCategories))
+                setFilterCategories(state.filterCategories);
+            if (Array.isArray(state.filterPriorities))
+                setFilterPriorities(state.filterPriorities);
+            if (Array.isArray(state.filterTypes))
+                setFilterTypes(state.filterTypes);
+            if (state.filterTaxonomies && typeof state.filterTaxonomies === 'object')
+                setFilterTaxonomies(state.filterTaxonomies);
+        }
+        else if (shouldResetTaxonomyFilters) {
+            setFilterCategories(activeCategories.map((category) => category.value));
+            setFilterPriorities(priorities.map((priority) => priority.value));
+            setFilterTypes(activeTypes.map((type) => type.value));
+            setFilterTaxonomies({});
+        }
         if (Array.isArray(state.filterStatus))
             setFilterStatus(state.filterStatus);
         if (Array.isArray(state.filterAssignees))
             setFilterAssignees(state.filterAssignees);
         if (typeof state.filterAssigneesAllSelected === 'boolean')
             setFilterAssigneesAllSelected(state.filterAssigneesAllSelected);
-        if (state.filterTaxonomies && typeof state.filterTaxonomies === 'object')
-            setFilterTaxonomies(state.filterTaxonomies);
         if (state.sortBy === 'created' || state.sortBy === 'priority' || state.sortBy === 'updated' || state.sortBy === 'complexity')
             setSortBy(state.sortBy);
         if (state.sortOrder === 'asc' || state.sortOrder === 'desc')
             setSortOrder(state.sortOrder);
-        if (typeof state.hasInitedFilters === 'boolean') {
+        if (shouldResetTaxonomyFilters) {
+            setHasInitedFilters(true);
+        }
+        else if (typeof state.hasInitedFilters === 'boolean' && taxonomyFiltersAreReady) {
             setHasInitedFilters(state.hasInitedFilters);
         }
-        else if (hasPersistedFilterState) {
+        else if (hasPersistedFilterState && taxonomyFiltersAreReady) {
             setHasInitedFilters(true);
         }
         if (typeof state.showChecklist === 'boolean')
@@ -1295,7 +1338,16 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         if (typeof state.exportEnvironment === 'string' && state.exportEnvironment.trim().length > 0) {
             setExportEnvironment(state.exportEnvironment.trim());
         }
-    }, []);
+    }, [activeCategories, activeTypes, currentFilterTaxonomySignature, priorities]);
+    useEffect(() => {
+        if (!currentFilterTaxonomySignature || !pendingPersistedTaxonomyUiStateRef.current)
+            return;
+        const pending = pendingPersistedTaxonomyUiStateRef.current;
+        pendingPersistedTaxonomyUiStateRef.current = null;
+        applyPersistedUiState(pending.state, {
+            skipActiveWorkspaceModule: pending.skipActiveWorkspaceModule
+        });
+    }, [applyPersistedUiState, currentFilterTaxonomySignature]);
     const loadPersistedUiState = useCallback(async (workspaceIdOverride) => {
         const targetWorkspaceId = String(workspaceIdOverride || currentWorkspaceIdRef.current || currentWorkspaceId || 'default').trim() || 'default';
         const uiStateLoadKey = `${runtimeMode}:${workspaceUiStateScope}:${targetWorkspaceId}`;
@@ -1369,6 +1421,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
             filterAssignees,
             filterAssigneesAllSelected,
             filterTaxonomies,
+            ...(currentFilterTaxonomySignature ? { filterTaxonomySignature: currentFilterTaxonomySignature } : {}),
             sortBy,
             sortOrder,
             hasInitedFilters,
@@ -1404,6 +1457,7 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         filterAssignees,
         filterAssigneesAllSelected,
         filterTaxonomies,
+        currentFilterTaxonomySignature,
         sortBy,
         sortOrder,
         hasInitedFilters,
@@ -2557,6 +2611,9 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         setInitiatives((current) => upsertEntityById(current, data));
         return data;
     }, [fetchPlanningEntities]);
+    const refreshPlanningEntitiesInBackground = useCallback(() => {
+        void fetchPlanningEntities();
+    }, [fetchPlanningEntities]);
     const archiveInitiative = useCallback(async (id) => {
         const res = await fetch(`/api/taskforce/initiative/${encodeURIComponent(id)}/archive`, {
             method: 'POST',
@@ -2565,10 +2622,10 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         if (!res.ok) {
             throw new Error(data?.error || `Failed to archive initiative (${res.status})`);
         }
-        await fetchPlanningEntities();
         setInitiatives((current) => upsertEntityById(current, data));
+        refreshPlanningEntitiesInBackground();
         return data;
-    }, [fetchPlanningEntities]);
+    }, [refreshPlanningEntitiesInBackground]);
     const unarchiveInitiative = useCallback(async (id) => {
         const res = await fetch(`/api/taskforce/initiative/${encodeURIComponent(id)}/unarchive`, {
             method: 'POST',
@@ -2577,10 +2634,10 @@ export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, on
         if (!res.ok) {
             throw new Error(data?.error || `Failed to unarchive initiative (${res.status})`);
         }
-        await fetchPlanningEntities();
         setInitiatives((current) => upsertEntityById(current, data));
+        refreshPlanningEntitiesInBackground();
         return data;
-    }, [fetchPlanningEntities]);
+    }, [refreshPlanningEntitiesInBackground]);
     const createWorkstream = useCallback(async (payload) => {
         const res = await fetch('/api/taskforce/workstream', {
             method: 'POST',

package/dist/hooks/workspace/workspaceLocalState.d.ts

@@ -1,5 +1,11 @@
 import type { TaskAssignee } from '../../types';
 import type { TaskSortKey } from '../../utils/taxonomySorting.js';
+export interface FilterTaxonomySignature {
+    categories: string[];
+    types: string[];
+    priorities: string[];
+    taxonomies: Record<string, string[]>;
+}
 export interface PersistedUiState {
     groupBy?: 'category' | 'type' | 'priority' | 'approach' | 'assignee' | 'status' | 'complexity' | 'schedule' | 'docs';
     activeWorkspaceModule?: 'tasks' | 'docs' | 'annotate' | 'workflows' | 'agents';
@@ -13,6 +19,7 @@ export interface PersistedUiState {
     filterAssignees?: TaskAssignee[];
     filterAssigneesAllSelected?: boolean;
     filterTaxonomies?: Record<string, (string | number)[]>;
+    filterTaxonomySignature?: FilterTaxonomySignature;
     sortBy?: TaskSortKey;
     sortOrder?: 'asc' | 'desc';
     hasInitedFilters?: boolean;
@@ -28,6 +35,24 @@ type RemoteUiStatePersistResult = {
     response?: Response;
     payload?: any;
 };
+export declare function buildFilterTaxonomySignature(input: {
+    categories: Array<{
+        value?: unknown;
+    }>;
+    types: Array<{
+        value?: unknown;
+    }>;
+    priorities: Array<{
+        value?: unknown;
+    }>;
+    taxonomies?: Array<{
+        id?: unknown;
+        options?: Array<{
+            value?: unknown;
+        }>;
+    }>;
+}): FilterTaxonomySignature | null;
+export declare function areFilterTaxonomySignaturesEqual(left: FilterTaxonomySignature | null | undefined, right: FilterTaxonomySignature | null | undefined): boolean;
 export declare function generateClientUuid(): string;
 export declare function logBootstrapDebug(event: string, details?: Record<string, unknown>): void;
 export declare function resetRemoteUiStatePersistCache(): void;

package/dist/hooks/workspace/workspaceLocalState.js

@@ -4,6 +4,44 @@ const APP_UI_STATE_STORAGE_KEY_PREFIX = 'taskforce.uiState.app.v1';
 const BOOTSTRAP_DEBUG_LOG_KEY = 'taskforce.bootstrapDebug.v1';
 const REMOTE_UI_STATE_FAILURE_RETRY_MS = 5000;
 const remoteUiStatePersistCache = new Map();
+function normalizeSignatureValues(values) {
+    return Array.from(new Set(values
+        .map((value) => String(value ?? '').trim())
+        .filter((value) => value.length > 0))).sort();
+}
+export function buildFilterTaxonomySignature(input) {
+    const categories = normalizeSignatureValues(input.categories.map((category) => category.value));
+    const types = normalizeSignatureValues(input.types.map((type) => type.value));
+    const priorities = normalizeSignatureValues(input.priorities.map((priority) => priority.value));
+    if (categories.length === 0 || types.length === 0 || priorities.length === 0)
+        return null;
+    const taxonomies = {};
+    (input.taxonomies || []).forEach((taxonomy) => {
+        const id = String(taxonomy.id ?? '').trim();
+        if (!id)
+            return;
+        taxonomies[id] = normalizeSignatureValues((taxonomy.options || []).map((option) => option.value));
+    });
+    return { categories, types, priorities, taxonomies };
+}
+function haveSameStringValues(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+export function areFilterTaxonomySignaturesEqual(left, right) {
+    if (!left || !right)
+        return false;
+    if (!haveSameStringValues(left.categories || [], right.categories || []))
+        return false;
+    if (!haveSameStringValues(left.types || [], right.types || []))
+        return false;
+    if (!haveSameStringValues(left.priorities || [], right.priorities || []))
+        return false;
+    const leftTaxonomyKeys = Object.keys(left.taxonomies || {}).sort();
+    const rightTaxonomyKeys = Object.keys(right.taxonomies || {}).sort();
+    if (!haveSameStringValues(leftTaxonomyKeys, rightTaxonomyKeys))
+        return false;
+    return leftTaxonomyKeys.every((key) => (haveSameStringValues(left.taxonomies[key] || [], right.taxonomies[key] || [])));
+}
 export function generateClientUuid() {
     if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
         return crypto.randomUUID();

package/dist/mcp/adminWorkspaceRegistrar.js

@@ -66,16 +66,6 @@ export function registerAdminWorkspaceTools(registerTool, executeTool) {
             required: ['types'],
         },
     }));
-    register('bulk_update_type', (context) => ({
-        description: context.describeTool('Bulk-update tasks from one task type to another. Use get_config first to confirm the current valid type values.'),
-        inputSchema: {
-            properties: {
-                fromType: stringProperty('Current task type value to replace.', context.typeEnum),
-                toType: stringProperty('Replacement task type value.', context.typeEnum),
-            },
-            required: ['fromType', 'toType'],
-        },
-    }));
     register('bulk_update_fields', (context) => ({
         description: context.describeTool('Apply field updates to multiple tasks in one request. Use get_config first to confirm valid taxonomy values before calling this tool.'),
         inputSchema: {

package/dist/mcp/clientIntegrations.d.ts

@@ -1,5 +1,5 @@
 import { type AiProfileBootstrapConfig } from './aiProfileBootstrap.js';
-export type McpClientId = 'general' | 'cursor' | 'cline' | 'vscode' | 'windsurf' | 'antigravity' | 'openclaw' | 'codex' | 'claude-code' | 'gemini-cli' | 'claude-desktop' | 'chatgpt-desktop';
+export type McpClientId = 'general' | 'cursor' | 'cline' | 'vscode' | 'kiro' | 'windsurf' | 'antigravity' | 'openclaw' | 'codex' | 'grok' | 'claude-code' | 'gemini-cli' | 'claude-desktop' | 'chatgpt-desktop';
 export interface McpClientOption {
     id: McpClientId;
     label: string;

package/dist/mcp/clientIntegrations.js

@@ -4,10 +4,12 @@ const LOCAL_AI_PROFILE_DEFAULTS = {
     cursor: { name: 'Cursor', icon: 'Bot', role: 'IDE coding assistant', provider: 'Cursor', model: 'Cursor', surfaceType: 'ide' },
     cline: { name: 'Cline', icon: 'Bot', role: 'IDE coding assistant', provider: 'Cline', model: 'Cline', surfaceType: 'ide' },
     vscode: { name: 'VS Code Copilot', icon: 'Bot', role: 'IDE coding assistant', provider: 'Microsoft', model: 'Copilot', surfaceType: 'ide' },
+    kiro: { name: 'Kiro', icon: 'Bot', role: 'IDE coding assistant', provider: 'Amazon', model: 'Kiro', surfaceType: 'ide' },
     windsurf: { name: 'Windsurf', icon: 'Bot', role: 'IDE coding assistant', provider: 'Windsurf', model: 'Windsurf', surfaceType: 'ide' },
     antigravity: { name: 'Antigravity', icon: 'Bot', role: 'Coding agent', provider: 'Google', model: 'Antigravity', surfaceType: 'coding_tool' },
     openclaw: { name: 'OpenClaw', icon: 'Bot', role: 'AI agent', provider: 'OpenClaw', model: 'OpenClaw', surfaceType: 'agent' },
     codex: { name: 'Codex', icon: 'Bot', role: 'Coding agent', provider: 'OpenAI', model: 'Codex', surfaceType: 'cli' },
+    grok: { name: 'Grok CLI', icon: 'Bot', role: 'Coding agent', provider: 'xAI', model: 'Grok CLI', surfaceType: 'cli' },
     'claude-code': { name: 'Claude Code', icon: 'Bot', role: 'Coding agent', provider: 'Anthropic', model: 'Claude Code', surfaceType: 'cli' },
     'gemini-cli': { name: 'Gemini CLI', icon: 'Bot', role: 'Coding agent', provider: 'Google', model: 'Gemini CLI', surfaceType: 'cli' },
     'claude-desktop': { name: 'Claude Desktop', icon: 'Bot', role: 'Desktop AI collaborator', provider: 'Anthropic', model: 'Claude Desktop', surfaceType: 'chat_app' },
@@ -32,6 +34,8 @@ export const MCP_CLIENT_OPTIONS = [
     { id: 'codex', label: 'Codex' },
     { id: 'cursor', label: 'Cursor' },
     { id: 'gemini-cli', label: 'Gemini CLI' },
+    { id: 'grok', label: 'Grok CLI' },
+    { id: 'kiro', label: 'Kiro' },
     { id: 'openclaw', label: 'OpenClaw' },
     { id: 'vscode', label: 'VS Code / Copilot' },
     { id: 'windsurf', label: 'Windsurf' },
@@ -149,6 +153,18 @@ export function buildCloudMcpClientIntegration(input) {
                 instructionLabel: 'VS Code Configuration Instructions',
                 instructionText: buildConfigurationInstruction('Open .vscode/mcp.json or MCP: Open User Configuration and add this server under the servers object.')
             };
+        case 'kiro':
+            return {
+                clientId,
+                kind: 'json',
+                rootKey: 'mcpServers',
+                serverConfig: {
+                    url: endpoint,
+                    headers
+                },
+                instructionLabel: 'Kiro Configuration Instructions',
+                instructionText: buildConfigurationInstruction('Open .kiro/settings/mcp.json in your workspace (or ~/.kiro/settings/mcp.json for user-level config) and add this server under mcpServers.')
+            };
         case 'windsurf':
             return {
                 clientId,
@@ -199,6 +215,18 @@ export function buildCloudMcpClientIntegration(input) {
                 instructionLabel: 'Codex Configuration Instructions',
                 instructionText: buildConfigurationInstruction('Open ~/.codex/config.toml and add this Codex MCP entry.')
             };
+        case 'grok':
+            return {
+                clientId,
+                kind: 'text',
+                renderedText: [
+                    `[mcp_servers.${serverId}]`,
+                    `url = "${endpoint}"`,
+                    `headers = { ${Object.entries(headers).map(([key, value]) => `${key} = "${value}"`).join(', ')} }`
+                ].join('\n'),
+                instructionLabel: 'Grok CLI Configuration Instructions',
+                instructionText: buildConfigurationInstruction('Open ~/.grok/config.toml (or .grok/config.toml in your project for project-scoped config) and add this Grok CLI MCP entry.')
+            };
         case 'claude-code':
             return {
                 clientId,
@@ -288,6 +316,15 @@ export function buildLocalMcpClientIntegration(input) {
                 instructionLabel: 'VS Code Configuration Instructions',
                 instructionText: buildLocalConfigurationInstruction('Open .vscode/mcp.json or MCP: Open User Configuration and add this server under the servers object.')
             };
+        case 'kiro':
+            return {
+                clientId,
+                kind: 'json',
+                rootKey: 'mcpServers',
+                serverConfig: baseStdioConfig,
+                instructionLabel: 'Kiro Configuration Instructions',
+                instructionText: buildLocalConfigurationInstruction('Open .kiro/settings/mcp.json in your workspace (or ~/.kiro/settings/mcp.json for user-level config) and add this server under mcpServers.')
+            };
         case 'windsurf':
             return {
                 clientId,
@@ -332,6 +369,19 @@ export function buildLocalMcpClientIntegration(input) {
                 instructionLabel: 'Codex Configuration Instructions',
                 instructionText: buildLocalConfigurationInstruction('Open ~/.codex/config.toml and add this local MCP entry.')
             };
+        case 'grok':
+            return {
+                clientId,
+                kind: 'text',
+                renderedText: [
+                    `[mcp_servers.${serverId}]`,
+                    `command = ${formatTomlString(serverConfig.command)}`,
+                    `args = ${formatTomlArray(serverConfig.args)}`,
+                    ...buildTomlEnvAssignment(serverConfig.env)
+                ].join('\n'),
+                instructionLabel: 'Grok CLI Configuration Instructions',
+                instructionText: buildLocalConfigurationInstruction('Open ~/.grok/config.toml (or .grok/config.toml in your project for project-scoped config) and add this local Grok CLI MCP entry.')
+            };
         case 'claude-code':
             return {
                 clientId,

package/dist/mcp/clientProfileDefaults.js

@@ -16,8 +16,12 @@ export function getDefaultAiProfileMetadataForClient(clientId) {
             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: 'CLI Coding Agent', provider: 'Google', model: 'Gemini', surfaceType: 'cli' };
+        case 'grok':
+            return { icon: 'Sparkles', color: '#111827', description: 'Grok CLI coding agent connected through MCP.', role: 'CLI Coding Agent', provider: 'xAI', model: 'Grok CLI', surfaceType: 'cli' };
         case 'vscode':
             return { icon: 'Code2', color: '#2563eb', description: 'VS Code MCP-connected coding agent.', role: 'Coding Agent', provider: null, model: null, surfaceType: 'ide' };
+        case 'kiro':
+            return { icon: 'Bot', color: '#7c3aed', description: 'Kiro IDE-connected AI assistant.', role: 'IDE coding assistant', provider: 'Amazon', model: null, surfaceType: 'ide' };
         case 'cline':
         case 'windsurf':
         case 'antigravity':

package/dist/mcp/collaborationRegistrar.js

@@ -23,11 +23,11 @@ export function registerCollaborationTools(registerTool, executeTool) {
         });
     };
     register('list_assignees', (context) => ({
-        description: context.describeTool('List eligible assignees for the active workspace. Returns human workspace members and AI profiles that can own tasks. Use this before create_task, update_task, assign_task, or bulk_assign_tasks when you need a valid assignee ID.'),
+        description: context.describeTool('List eligible assignees for the active workspace. Returns human workspace members and AI profiles that can own tasks. Use this before create_task, update_task, or bulk_update_fields when you need a valid assignee ID.'),
         inputSchema: { properties: {} },
     }));
     register('get_current_profile', (context) => ({
-        description: context.describeTool('Inspect the effective AI profile for this session. Use this when an agent needs to know its current profile id before filtering for tasks assigned to itself. If no profile is currently bound, this tool explains how to bootstrap with resolve_profile. You may also pass your own profileToken to inspect a stateless AI profile without mutating session state. The response includes your profileToken only for private agent/client storage; do not write it to repos, task comments, task attachments, logs, generated docs, or shared output.'),
+        description: context.describeTool('Inspect current AI identity for this call (ambient session, connection bootstrap, or explicit profileToken). Returns identityBound (true if this invocation has a resolved identity), bindingSource, profile, taskFilter, suggestedArgs, and guidance. Stateless/scheduled agents: call with profileToken if no ambient bind; use the returned suggestedArgs (with assignee) for list_tasks and pass profileToken on writes. Call before mutating or to decide on resolve_profile.'),
         inputSchema: {
             properties: {
                 profileToken: stringProperty('Optional AI profile token to inspect when no profile is currently bound in session state. Pass only a token previously issued to this AI identity.'),
@@ -35,7 +35,7 @@ export function registerCollaborationTools(registerTool, executeTool) {
         },
     }));
     register('resolve_profile', (context) => ({
-        description: context.describeTool('Resolve or create the current AI collaborator profile for this workspace. On first bootstrap, omit profileToken and Taskforce will create a named AI profile, issue a stable profileToken, and return the profile id to use in assignee, createdBy, and comment author fields on later calls. Store the returned profileToken only in private agent/client state and include it on future mutating calls when your MCP client does not preserve session identity. Never write profileToken values to repos, task comments, task attachments, logs, generated docs, or shared output. When a valid profileToken is provided, Taskforce resolves the existing profile and updates any supplied presentation fields such as name, icon, color, description, role, provider, model, and surfaceType. Update semantics: omitted optional fields leave existing stored values unchanged. For description, role, provider, and model, empty strings are ignored rather than clearing. For surfaceType, null or an empty string clears the stored value; valid enum values replace it.'),
+        description: context.describeTool('Resolve or create this AI collaborator profile. For stateless agents (no ambient binding): call with name + surfaceType (and profileToken to re-use); the response includes created, profileToken, profile, *plus* identityBound, bindingSource, taskFilter, suggestedArgs, nextTool, guidance. Store profileToken privately only. Use suggestedArgs for list_tasks; pass profileToken on mutating calls. Never write profileToken to repos, tasks, logs, or docs.'),
         inputSchema: {
             properties: {
                 name: stringProperty('Display name for the AI collaborator.'),