@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/cli.js

@@ -3,6 +3,9 @@ import { exec } from 'child_process';
 import { platform } from 'os';
 import { readFileSync, existsSync, realpathSync } from 'fs';
 import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { TASKFORCE_CLOUD_ENVIRONMENTS } from './config/cloudEnvironment.js';
+import { resolveDeploymentConfig } from './config/deployment.js';
 /**
  * Taskforce CLI
  *
@@ -10,7 +13,8 @@ import { join, dirname } from 'path';
  * npx taskforce open [port]
  */
 const args = process.argv.slice(2);
-const command = args[0] || 'open';
+const versionFlagRequested = args.includes('--version') || args.includes('-v');
+const command = versionFlagRequested ? 'version' : (args[0] || 'open');
 function normalizeOpenEnvironmentPreset(raw) {
     const normalized = String(raw || '').trim().toLowerCase();
     if (normalized === 'production')
@@ -45,6 +49,17 @@ function parseOpenCommandOptions(argv) {
     }
     return { preferredPort: arg2AsPort, preset };
 }
+function getCliVersion() {
+    try {
+        const cliDir = dirname(fileURLToPath(import.meta.url));
+        const packageJsonPath = join(cliDir, '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        return String(pkg.version || 'unknown');
+    }
+    catch {
+        return 'unknown';
+    }
+}
 /**
  * Find project root by traversing up to find package.json with taskforce
  */
@@ -90,18 +105,58 @@ function openBrowser(url) {
     const start = (platform() === 'darwin' ? 'open' : platform() === 'win32' ? 'start' : 'xdg-open');
     exec(`${start} ${url}`);
 }
+function printVersion(scriptFriendly = false) {
+    const version = getCliVersion();
+    if (scriptFriendly) {
+        console.log(version);
+        return;
+    }
+    console.log(`Taskforce CLI v${version}`);
+}
+function printStatus(projectRoot) {
+    const deployment = resolveDeploymentConfig(process.env);
+    const version = getCliVersion();
+    console.log('\x1b[35mTaskforce Status\x1b[0m');
+    console.log(`Version: ${version}`);
+    console.log(`Project root: ${projectRoot}`);
+    console.log(`Runtime mode: ${deployment.runtimeMode}`);
+    console.log(`Cloud environment: ${deployment.cloudEnvironment || 'not set'}`);
+    console.log(`Base URL: ${deployment.baseUrl || 'not set'}`);
+    console.log(`API base URL: ${deployment.apiBaseUrl || 'not set'}`);
+    console.log(`Cloud auth URL: ${deployment.cloudAuthBaseUrl || 'not set'}`);
+    console.log(`Cloud MCP URL: ${deployment.cloudMcpBaseUrl || 'not set'}`);
+    console.log(`WebSocket base URL: ${deployment.wsBaseUrl || 'not set'}`);
+    console.log(`Cloud auth via local proxy: ${deployment.cloudAuthViaLocalProxy ? 'yes' : 'no'}`);
+    if (deployment.warnings.length > 0) {
+        console.log('Warnings:');
+        for (const warning of deployment.warnings) {
+            console.log(`- ${warning}`);
+        }
+    }
+    else {
+        console.log('Warnings: none');
+    }
+}
 /**
  * Main CLI logic
  */
 async function main() {
-    if (command === 'help' || (command !== 'open' && command !== 'mcp')) {
+    if (command === 'help' || (command !== 'open' && command !== 'mcp' && command !== 'version' && command !== 'status')) {
         console.log('\x1b[35mTaskforce CLI\x1b[0m');
         console.log('\nUsage:');
         console.log('  taskforce <command> [options]');
         console.log('\nAvailable commands:');
         console.log('  open [port]                         - Starts Taskforce on an unused port and opens it (default start port 5174)');
-        console.log('  mcp [path]      - Starts the Model Context Protocol (MCP) server for the specified project');
-        console.log('  help            - Shows this help message');
+        console.log('  mcp [path]                          - Starts the Model Context Protocol (MCP) server for the specified project');
+        console.log('  status                              - Prints the resolved Taskforce CLI/runtime status');
+        console.log('  version                             - Prints the Taskforce CLI version');
+        console.log('  help                                - Shows this help message');
+        console.log('\nFlags:');
+        console.log('  -v, --version                       - Prints the Taskforce CLI version');
+        return;
+    }
+    if (command === 'version') {
+        printVersion(versionFlagRequested);
         return;
     }
     // 1. Handle MCP Command
@@ -131,6 +186,10 @@ async function main() {
         // Optional: warn if no package.json found at all?
         // For now, silent fallback is better for "just works" experience
     }
+    if (command === 'status') {
+        printStatus(projectRoot);
+        return;
+    }
     console.log(`\x1b[32m✓ Found Taskforce in ${projectRoot}\x1b[0m`);
     // 2. Always start a new server on an unused port
     console.log(`\x1b[36m✨ Starting Taskforce server on an unused port...\x1b[0m`);
@@ -140,28 +199,18 @@ async function main() {
         if (!process.env.TASKFORCE_RUNTIME_MODE) {
             process.env.TASKFORCE_RUNTIME_MODE = 'local';
         }
-        const hasExternalCloudEndpoint = Boolean(String(process.env.VITE_TASKFORCE_BASE_URL || '').trim()
-            || String(process.env.TASKFORCE_BASE_URL || '').trim()
-            || String(process.env.VITE_TASKFORCE_API_BASE_URL || '').trim()
-            || String(process.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL || '').trim());
+        const existingDeployment = resolveDeploymentConfig(process.env);
+        const hasExternalCloudEndpoint = Boolean(existingDeployment.cloudBaseUrl);
         const effectivePreset = openPreset || (hasExternalCloudEndpoint ? null : 'production');
-        if (effectivePreset === 'production') {
-            process.env.VITE_TASKFORCE_BASE_URL = 'https://app.taskforcehq.ai';
-            process.env.VITE_TASKFORCE_API_BASE_URL = 'https://app.taskforcehq.ai';
-            process.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL = 'https://app.taskforcehq.ai';
-            console.log('\x1b[36m[Taskforce] Using production cloud endpoint preset\x1b[0m');
-        }
-        else if (effectivePreset === 'staging') {
-            process.env.VITE_TASKFORCE_BASE_URL = 'https://staging-app.taskforcehq.ai';
-            process.env.VITE_TASKFORCE_API_BASE_URL = 'https://staging-app.taskforcehq.ai';
-            process.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL = 'https://staging-app.taskforcehq.ai';
-            console.log('\x1b[36m[Taskforce] Using staging cloud endpoint preset\x1b[0m');
-        }
-        else if (effectivePreset === 'performance') {
-            process.env.VITE_TASKFORCE_BASE_URL = 'https://performance-app.taskforcehq.ai';
-            process.env.VITE_TASKFORCE_API_BASE_URL = 'https://performance-app.taskforcehq.ai';
-            process.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL = 'https://performance-app.taskforcehq.ai';
-            console.log('\x1b[36m[Taskforce] Using performance cloud endpoint preset\x1b[0m');
+        if (effectivePreset) {
+            const cloudBaseUrl = TASKFORCE_CLOUD_ENVIRONMENTS[effectivePreset].appBaseUrl;
+            const cloudMcpBaseUrl = TASKFORCE_CLOUD_ENVIRONMENTS[effectivePreset].mcpBaseUrl;
+            process.env.TASKFORCE_CLOUD_ENVIRONMENT = effectivePreset;
+            process.env.VITE_TASKFORCE_BASE_URL = cloudBaseUrl;
+            process.env.VITE_TASKFORCE_API_BASE_URL = cloudBaseUrl;
+            process.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL = cloudBaseUrl;
+            process.env.VITE_TASKFORCE_CLOUD_MCP_BASE_URL = cloudMcpBaseUrl;
+            console.log(`\x1b[36m[Taskforce] Using ${effectivePreset} cloud endpoint preset\x1b[0m`);
         }
         else if (hasExternalCloudEndpoint) {
             console.log('\x1b[36m[Taskforce] Using cloud endpoint from environment variables\x1b[0m');

package/dist/compat/deploymentCompat.d.ts

@@ -0,0 +1,12 @@
+import { type TaskforceCloudEnvironment } from '../config/cloudEnvironment.js';
+export interface EnvLike {
+    [key: string]: unknown;
+}
+export interface CompatWarningHandler {
+    (message: string): void;
+}
+export interface CompatCloudEnvironmentResolution {
+    cloudEnvironment: TaskforceCloudEnvironment | null;
+    warnings: string[];
+}
+export declare function resolveCompatCloudEnvironment(env: EnvLike, onWarning?: CompatWarningHandler): CompatCloudEnvironmentResolution;

package/dist/compat/deploymentCompat.js

@@ -0,0 +1,43 @@
+import { MIGRATION_COMPAT_ENABLED } from '../runtime/migrationFlags.js';
+import { parseTaskforceCloudEnvironment, resolveTaskforceCloudEnvironmentFromBaseUrl } from '../config/cloudEnvironment.js';
+function readEnvValue(env, key) {
+    return String(env[key] || '').trim();
+}
+function appendWarning(warnings, message, onWarning) {
+    warnings.push(message);
+    onWarning?.(message);
+}
+export function resolveCompatCloudEnvironment(env, onWarning) {
+    const warnings = [];
+    if (!MIGRATION_COMPAT_ENABLED) {
+        return { cloudEnvironment: null, warnings };
+    }
+    // COMPAT_REMOVE_AFTER: 0.4.0
+    // COMPAT_TRACK: runtime-env-config-v1
+    const legacyEnvAlias = readEnvValue(env, 'ENV');
+    const legacyEnv = parseTaskforceCloudEnvironment(legacyEnvAlias);
+    if (legacyEnv) {
+        appendWarning(warnings, `[Taskforce compat] ENV=${legacyEnvAlias} is deprecated; set TASKFORCE_CLOUD_ENVIRONMENT=${legacyEnv} instead.`, onWarning);
+        return { cloudEnvironment: legacyEnv, warnings };
+    }
+    // COMPAT_REMOVE_AFTER: 0.4.0
+    // COMPAT_TRACK: runtime-env-config-v1
+    const legacyBaseCandidates = [
+        { key: 'TASKFORCE_CLOUD_PROXY_BASE_URL', value: readEnvValue(env, 'TASKFORCE_CLOUD_PROXY_BASE_URL') },
+        { key: 'VITE_TASKFORCE_CLOUD_AUTH_BASE_URL', value: readEnvValue(env, 'VITE_TASKFORCE_CLOUD_AUTH_BASE_URL') },
+        { key: 'VITE_TASKFORCE_CLOUD_MCP_BASE_URL', value: readEnvValue(env, 'VITE_TASKFORCE_CLOUD_MCP_BASE_URL') },
+        { key: 'VITE_TASKFORCE_API_BASE_URL', value: readEnvValue(env, 'VITE_TASKFORCE_API_BASE_URL') },
+        { key: 'VITE_TASKFORCE_BASE_URL', value: readEnvValue(env, 'VITE_TASKFORCE_BASE_URL') },
+        { key: 'TASKFORCE_BASE_URL', value: readEnvValue(env, 'TASKFORCE_BASE_URL') }
+    ];
+    for (const candidate of legacyBaseCandidates) {
+        if (!candidate.value)
+            continue;
+        const inferred = resolveTaskforceCloudEnvironmentFromBaseUrl(candidate.value);
+        if (!inferred)
+            continue;
+        appendWarning(warnings, `[Taskforce compat] ${candidate.key} is being used to infer TASKFORCE_CLOUD_ENVIRONMENT=${inferred}. Set TASKFORCE_CLOUD_ENVIRONMENT explicitly.`, onWarning);
+        return { cloudEnvironment: inferred, warnings };
+    }
+    return { cloudEnvironment: null, warnings };
+}

package/dist/compat/workspaceSyncCompat.d.ts

@@ -0,0 +1,6 @@
+import { type WorkspaceSyncStateV2 } from '../sync/workspaceSyncState.js';
+export interface WorkspaceSyncStateCompatResult {
+    state: WorkspaceSyncStateV2;
+    changed: boolean;
+}
+export declare function normalizeWorkspaceSyncStateCompat(rawState: Record<string, unknown> | null | undefined): WorkspaceSyncStateCompatResult;

package/dist/compat/workspaceSyncCompat.js

@@ -0,0 +1,79 @@
+import { MIGRATION_COMPAT_ENABLED } from '../runtime/migrationFlags.js';
+import { createDefaultWorkspaceSyncState } from '../sync/workspaceSyncState.js';
+function normalizeTimestamp(value) {
+    const normalized = String(value || '').trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function resolveLegacyPhase(input, base) {
+    const enabled = Boolean(input.enabled ?? input.cloudSyncEnabled);
+    if (!enabled)
+        return 'idle';
+    const versionedPhase = String(input.phase || '').trim().toLowerCase();
+    if (versionedPhase === 'idle' || versionedPhase === 'provision-local' || versionedPhase === 'attach-cloud' || versionedPhase === 'active' || versionedPhase === 'error') {
+        return versionedPhase;
+    }
+    const bootstrapMode = String(input.bootstrapMode || '').trim().toLowerCase();
+    if (bootstrapMode === 'provision-local' || bootstrapMode === 'attach-cloud') {
+        return bootstrapMode;
+    }
+    const sourceOfTruth = String(input.sourceOfTruth || '').trim().toLowerCase();
+    const onboardingCompleted = Boolean(input.onboardingCompleted);
+    if (onboardingCompleted) {
+        return 'active';
+    }
+    if (sourceOfTruth === 'cloud') {
+        return base.lastPullAt ? 'active' : 'attach-cloud';
+    }
+    if (sourceOfTruth === 'local') {
+        return (base.lastPullAt || base.lastPushAt) ? 'active' : 'provision-local';
+    }
+    if (base.lastPullAt || base.lastPushAt) {
+        return 'active';
+    }
+    return 'active';
+}
+export function normalizeWorkspaceSyncStateCompat(rawState) {
+    const base = createDefaultWorkspaceSyncState();
+    if (!rawState || typeof rawState !== 'object') {
+        return { state: base, changed: false };
+    }
+    const state = rawState;
+    const rawLastErrorMessage = state.lastErrorMessage;
+    const normalizedLastErrorMessage = typeof rawLastErrorMessage === 'string' && rawLastErrorMessage.trim().length > 0
+        ? rawLastErrorMessage
+        : null;
+    const normalized = {
+        version: 2,
+        enabled: Boolean(state.enabled ?? state.cloudSyncEnabled),
+        phase: 'idle',
+        pullCursor: normalizeTimestamp(state.pullCursor),
+        lastPullAt: normalizeTimestamp(state.lastPullAt),
+        lastPushAt: normalizeTimestamp(state.lastPushAt),
+        lastSyncedAt: normalizeTimestamp(state.lastSyncedAt),
+        lastErrorMessage: normalizedLastErrorMessage
+    };
+    normalized.phase = resolveLegacyPhase(state, normalized);
+    if (!normalized.enabled) {
+        normalized.phase = 'idle';
+        normalized.pullCursor = null;
+    }
+    if (!MIGRATION_COMPAT_ENABLED) {
+        return {
+            state: normalized,
+            changed: false
+        };
+    }
+    const currentVersion = Number(state.version || 0);
+    const changed = currentVersion !== 2
+        || Boolean(state.enabled ?? state.cloudSyncEnabled) !== normalized.enabled
+        || String(state.phase || '').trim() !== normalized.phase
+        || normalizeTimestamp(state.pullCursor) !== normalized.pullCursor
+        || normalizeTimestamp(state.lastPullAt) !== normalized.lastPullAt
+        || normalizeTimestamp(state.lastPushAt) !== normalized.lastPushAt
+        || normalizeTimestamp(state.lastSyncedAt) !== normalized.lastSyncedAt
+        || normalizedLastErrorMessage !== normalized.lastErrorMessage;
+    return {
+        state: normalized,
+        changed
+    };
+}

package/dist/compat/workspaceSyncCompat.test.js

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeWorkspaceSyncStateCompat } from './workspaceSyncCompat';
+describe('workspaceSyncCompat', () => {
+    it('maps legacy disabled sync state to v2 idle state', () => {
+        const result = normalizeWorkspaceSyncStateCompat({
+            cloudSyncEnabled: false,
+            sourceOfTruth: null,
+            onboardingCompleted: false,
+            bootstrapMode: null,
+            pullCursor: 'stale-cursor'
+        });
+        expect(result.changed).toBe(true);
+        expect(result.state).toEqual({
+            version: 2,
+            enabled: false,
+            phase: 'idle',
+            pullCursor: null,
+            lastPullAt: null,
+            lastPushAt: null,
+            lastSyncedAt: null,
+            lastErrorMessage: null
+        });
+    });
+    it('maps legacy local bootstrap state to provision-local phase', () => {
+        const result = normalizeWorkspaceSyncStateCompat({
+            cloudSyncEnabled: true,
+            sourceOfTruth: 'local',
+            onboardingCompleted: false,
+            bootstrapMode: null
+        });
+        expect(result.state.phase).toBe('provision-local');
+    });
+    it('maps legacy cloud bootstrap state to attach-cloud phase', () => {
+        const result = normalizeWorkspaceSyncStateCompat({
+            cloudSyncEnabled: true,
+            sourceOfTruth: 'cloud',
+            onboardingCompleted: false,
+            bootstrapMode: null
+        });
+        expect(result.state.phase).toBe('attach-cloud');
+    });
+    it('maps legacy completed sync state to active phase', () => {
+        const result = normalizeWorkspaceSyncStateCompat({
+            cloudSyncEnabled: true,
+            sourceOfTruth: 'cloud',
+            onboardingCompleted: true,
+            lastPullAt: '2026-03-15T15:00:00.000Z'
+        });
+        expect(result.state.phase).toBe('active');
+    });
+    it('keeps legacy cloud attach state in attach-cloud until a pull has completed', () => {
+        const result = normalizeWorkspaceSyncStateCompat({
+            cloudSyncEnabled: true,
+            sourceOfTruth: 'cloud',
+            onboardingCompleted: false,
+            lastPullAt: null,
+            lastPushAt: '2026-03-15T15:00:00.000Z'
+        });
+        expect(result.state.phase).toBe('attach-cloud');
+    });
+    it('normalizes lastErrorMessage correctly when present in raw state', () => {
+        const result = normalizeWorkspaceSyncStateCompat({
+            version: 2,
+            enabled: true,
+            phase: 'error',
+            lastErrorMessage: 'Workspace sync pull failed (500)'
+        });
+        expect(result.state.lastErrorMessage).toBe('Workspace sync pull failed (500)');
+    });
+    it('defaults lastErrorMessage to null when absent from raw state', () => {
+        const result = normalizeWorkspaceSyncStateCompat({
+            version: 2,
+            enabled: true,
+            phase: 'active'
+        });
+        expect(result.state.lastErrorMessage).toBeNull();
+    });
+    it('defaults lastErrorMessage to null when present but empty string', () => {
+        const result = normalizeWorkspaceSyncStateCompat({
+            version: 2,
+            enabled: true,
+            phase: 'active',
+            lastErrorMessage: ''
+        });
+        expect(result.state.lastErrorMessage).toBeNull();
+    });
+});

package/dist/components/features/AgentsModule.d.ts

@@ -0,0 +1,5 @@
+interface AgentsModuleProps {
+    workspaceId: string;
+}
+export declare function AgentsModule({ workspaceId }: AgentsModuleProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/features/AgentsModule.js

@@ -0,0 +1,131 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { AlertTriangle, Bot, Check, Clock3, Loader2, Orbit, Sparkles } from 'lucide-react';
+import styles from '../../Taskforce.module.css';
+import { AI_PROFILE_SURFACE_TYPE_SECTION_ORDER, formatAiProfileSurfaceTypeLabel, formatAiProfileSurfaceTypeSectionLabel, getAiProfileSurfaceTypeSection, parseAiProfileSurfaceType } from '../../shared/aiProfileSurfaceType.js';
+export function AgentsModule({ workspaceId }) {
+    const [aiProfiles, setAiProfiles] = useState([]);
+    const [aiProfilesLoading, setAiProfilesLoading] = useState(false);
+    const [aiProfileMergeState, setAiProfileMergeState] = useState(null);
+    const [aiProfileMergeStatus, setAiProfileMergeStatus] = useState(null);
+    const [selectedGroupId, setSelectedGroupId] = useState(null);
+    const loadAiProfiles = useCallback(async () => {
+        if (!workspaceId)
+            return;
+        setAiProfilesLoading(true);
+        try {
+            const res = await fetch(`/api/taskforce/workspace/assignee-options?workspaceId=${encodeURIComponent(workspaceId)}`, {
+                credentials: 'include',
+            });
+            const data = await res.json().catch(() => ({}));
+            const agents = Array.isArray(data?.assignees)
+                ? data.assignees
+                    .filter((assignee) => assignee.kind === 'agent')
+                    .map((assignee) => ({
+                    id: String(assignee.value || ''),
+                    name: String(assignee.label || assignee.value || 'Unknown Agent'),
+                    username: String(assignee.username || assignee.value || ''),
+                    icon: String(assignee.icon || 'Bot'),
+                    color: String(assignee.color || '#6B7280'),
+                    kind: String(assignee.kind || 'agent'),
+                    description: typeof assignee.description === 'string' ? assignee.description : null,
+                    role: typeof assignee.role === 'string' ? assignee.role : null,
+                    provider: typeof assignee.provider === 'string' ? assignee.provider : null,
+                    model: typeof assignee.model === 'string' ? assignee.model : null,
+                    surfaceType: parseAiProfileSurfaceType(assignee.surfaceType),
+                    createdAt: String(assignee.createdAt || ''),
+                    updatedAt: String(assignee.updatedAt || assignee.createdAt || ''),
+                    lastActiveAt: typeof assignee.lastActiveAt === 'string' ? assignee.lastActiveAt : null,
+                }))
+                : [];
+            setAiProfiles(agents);
+        }
+        finally {
+            setAiProfilesLoading(false);
+        }
+    }, [workspaceId]);
+    useEffect(() => {
+        void loadAiProfiles();
+    }, [loadAiProfiles]);
+    const groupedProfilesBySurfaceType = useMemo(() => {
+        const bySection = new Map();
+        for (const profile of aiProfiles) {
+            const section = getAiProfileSurfaceTypeSection(profile.surfaceType);
+            if (!bySection.has(section))
+                bySection.set(section, new Map());
+            const sectionEntries = bySection.get(section);
+            const key = profile.name.toLowerCase();
+            if (!sectionEntries.has(key))
+                sectionEntries.set(key, []);
+            sectionEntries.get(key).push(profile);
+        }
+        return AI_PROFILE_SURFACE_TYPE_SECTION_ORDER
+            .map((section) => ({
+            section,
+            label: formatAiProfileSurfaceTypeSectionLabel(section),
+            groups: Array.from(bySection.get(section)?.entries() || []).map(([key, profiles]) => ({
+                groupId: `${section}:${key}`,
+                section,
+                sectionLabel: formatAiProfileSurfaceTypeSectionLabel(section),
+                profiles,
+                primaryProfile: profiles[0]
+            }))
+        }))
+            .filter((entry) => entry.groups.length > 0);
+    }, [aiProfiles]);
+    const allGroups = useMemo(() => groupedProfilesBySurfaceType.flatMap((section) => section.groups), [groupedProfilesBySurfaceType]);
+    const selectedGroup = useMemo(() => allGroups.find((group) => group.groupId === selectedGroupId) || allGroups[0] || null, [allGroups, selectedGroupId]);
+    useEffect(() => {
+        if (!allGroups.length) {
+            if (selectedGroupId !== null)
+                setSelectedGroupId(null);
+            return;
+        }
+        if (!selectedGroupId || !allGroups.some((group) => group.groupId === selectedGroupId)) {
+            setSelectedGroupId(allGroups[0].groupId);
+        }
+    }, [allGroups, selectedGroupId]);
+    const handleMerge = async (keepId, mergeId) => {
+        setAiProfileMergeStatus(null);
+        try {
+            const res = await fetch('/api/taskforce/workspace/ai-profiles/merge', {
+                method: 'POST',
+                credentials: 'include',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ keepId, mergeId }),
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok) {
+                setAiProfileMergeStatus({ type: 'error', message: String(data?.error || 'Failed to merge AI profiles.') });
+                return;
+            }
+            setAiProfileMergeState(null);
+            setAiProfileMergeStatus({ type: 'success', message: 'AI profiles merged.' });
+            await loadAiProfiles();
+        }
+        catch {
+            setAiProfileMergeStatus({ type: 'error', message: 'Failed to merge AI profiles.' });
+        }
+    };
+    const formatTimestamp = (value) => {
+        const normalized = String(value || '').trim();
+        if (!normalized)
+            return 'Unknown';
+        const timestamp = Date.parse(normalized);
+        if (!Number.isFinite(timestamp))
+            return normalized;
+        return new Date(timestamp).toLocaleString(undefined, {
+            dateStyle: 'medium',
+            timeStyle: 'short'
+        });
+    };
+    return (_jsx("div", { className: `${styles.standalonePage} ${styles.standaloneContent}`, style: { overflow: 'auto' }, children: _jsx("div", { className: styles.settingsContent, style: { maxWidth: 960, margin: '0 auto', width: '100%' }, children: _jsx("div", { className: styles.settingGroup, children: _jsxs("div", { children: [_jsx("h4", { className: styles.settingSubTitle, children: "Registered AI Profiles" }), _jsx("p", { className: `${styles.settingsHint} ${styles.marginBottom12}`, children: "AI agents register profiles when connecting via MCP. Merge duplicates created when a token was lost." }), aiProfilesLoading && (_jsxs("div", { className: styles.settingsHint, children: [_jsx(Loader2, { size: 13, className: styles.spinner }), " Loading profiles\u2026"] })), !aiProfilesLoading && aiProfiles.length === 0 && (_jsx("div", { className: styles.settingsHint, children: "No AI profiles registered yet." })), !aiProfilesLoading && groupedProfilesBySurfaceType.length > 0 && (_jsxs("div", { className: styles.aiProfilesExplorer, children: [_jsx("div", { className: styles.aiProfilesListPane, children: _jsx("div", { className: styles.aiProfilesList, children: groupedProfilesBySurfaceType.map((section) => (_jsxs("div", { className: styles.aiProfilesSection, children: [_jsx("div", { className: styles.aiProfilesSectionHeader, children: section.label }), section.groups.map((group) => {
+                                                    const isSelected = selectedGroup?.groupId === group.groupId;
+                                                    const primary = group.primaryProfile;
+                                                    return (_jsxs("button", { type: "button", className: `${styles.aiProfileGroup} ${group.profiles.length > 1 ? styles.aiProfileGroupDuplicate : ''} ${isSelected ? styles.aiProfileGroupSelected : ''}`, onClick: () => setSelectedGroupId(group.groupId), "aria-pressed": isSelected, children: [_jsxs("div", { className: styles.aiProfileGroupHeader, children: [_jsx(Bot, { size: 13, style: { color: primary.color } }), _jsx("span", { className: styles.aiProfileName, children: primary.name }), group.profiles.length > 1 && (_jsxs("span", { className: styles.aiProfileDuplicateBadge, children: [_jsx(AlertTriangle, { size: 11 }), " ", group.profiles.length, " duplicates"] }))] }), _jsxs("div", { className: styles.settingsHint, style: { marginTop: 6 }, children: ["@", primary.username] }), (primary.surfaceType || primary.role || primary.provider || primary.model) && (_jsxs("div", { className: styles.aiProfileMetaRow, children: [primary.surfaceType && (_jsx("span", { className: styles.aiProfileSurfaceBadge, children: formatAiProfileSurfaceTypeLabel(primary.surfaceType) })), primary.role && _jsx("span", { children: primary.role }), primary.provider && _jsx("span", { children: primary.provider }), primary.model && _jsx("span", { children: primary.model })] })), primary.description && (_jsx("div", { className: styles.settingsHint, style: { marginTop: 4 }, children: primary.description }))] }, group.groupId));
+                                                })] }, section.section))) }) }), selectedGroup && (_jsx("div", { className: styles.aiProfileDetailPane, children: _jsxs("div", { className: styles.aiProfileDetailCard, children: [_jsxs("div", { className: styles.aiProfileDetailHero, children: [_jsx("div", { className: styles.aiProfileDetailIcon, style: { color: selectedGroup.primaryProfile.color }, children: _jsx(Bot, { size: 18 }) }), _jsxs("div", { className: styles.aiProfileDetailHeading, children: [_jsx("div", { className: styles.aiProfileDetailTitleRow, children: _jsx("h5", { className: styles.aiProfileDetailTitle, children: selectedGroup.primaryProfile.name }) }), _jsxs("div", { className: styles.aiProfileDetailMetaRow, children: [_jsxs("span", { className: styles.aiProfileDetailHandle, children: ["@", selectedGroup.primaryProfile.username] }), _jsx("span", { className: styles.aiProfileDetailSectionBadge, children: selectedGroup.sectionLabel }), selectedGroup.profiles.length > 1 && (_jsxs("span", { className: styles.aiProfileDetailLinkedCount, children: [selectedGroup.profiles.length, " linked"] }))] })] })] }), selectedGroup.primaryProfile.description && (_jsx("div", { className: styles.aiProfileDetailDescription, children: selectedGroup.primaryProfile.description })), _jsxs("div", { className: styles.aiProfileDetailGrid, children: [_jsxs("div", { className: styles.aiProfileDetailStat, children: [_jsxs("span", { className: styles.aiProfileDetailStatLabel, children: [_jsx(Sparkles, { size: 12 }), " Role"] }), _jsx("span", { className: styles.aiProfileDetailStatValue, children: selectedGroup.primaryProfile.role || 'Not set' })] }), _jsxs("div", { className: styles.aiProfileDetailStat, children: [_jsxs("span", { className: styles.aiProfileDetailStatLabel, children: [_jsx(Orbit, { size: 12 }), " Provider"] }), _jsx("span", { className: styles.aiProfileDetailStatValue, children: [selectedGroup.primaryProfile.provider, selectedGroup.primaryProfile.model].filter(Boolean).join(' · ') || 'Not set' })] }), _jsxs("div", { className: styles.aiProfileDetailStat, children: [_jsxs("span", { className: styles.aiProfileDetailStatLabel, children: [_jsx(Clock3, { size: 12 }), " Last active"] }), _jsx("span", { className: styles.aiProfileDetailStatValue, children: formatTimestamp(selectedGroup.primaryProfile.lastActiveAt) })] }), _jsxs("div", { className: styles.aiProfileDetailStat, children: [_jsxs("span", { className: styles.aiProfileDetailStatLabel, children: [_jsx(Clock3, { size: 12 }), " Updated"] }), _jsx("span", { className: styles.aiProfileDetailStatValue, children: formatTimestamp(selectedGroup.primaryProfile.updatedAt) })] })] }), _jsxs("div", { className: styles.aiProfileInstanceSection, children: [_jsxs("div", { className: styles.aiProfileInstanceSectionHeader, children: [_jsx("span", { children: "Profile instances" }), _jsx("span", { className: styles.settingsHint, children: "Choose a keeper here if duplicates need to be merged." })] }), _jsx("div", { className: styles.aiProfileInstanceList, children: selectedGroup.profiles.map((profile) => (_jsxs("div", { className: styles.aiProfileInstanceCard, children: [_jsxs("div", { className: styles.aiProfileInstanceTopRow, children: [_jsxs("div", { children: [_jsxs("div", { className: styles.aiProfileInstanceName, children: ["@", profile.username] }), _jsx("div", { className: styles.aiProfileIdChip, children: profile.id })] }), selectedGroup.profiles.length > 1 && aiProfileMergeState?.keepId === profile.id && (_jsx("span", { className: styles.aiProfileKeepBadge, children: "Keeping" }))] }), _jsxs("div", { className: styles.aiProfileInstanceMeta, children: [_jsxs("span", { children: ["Created ", formatTimestamp(profile.createdAt)] }), _jsxs("span", { children: ["Updated ", formatTimestamp(profile.updatedAt)] })] }), selectedGroup.profiles.length > 1 && aiProfileMergeState?.keepId !== profile.id && (_jsx("button", { className: styles.secondaryHeaderBtn, title: "Keep this profile, merge others into it", onClick: () => {
+                                                                        const otherId = selectedGroup.profiles.find((candidate) => candidate.id !== profile.id)?.id;
+                                                                        if (otherId)
+                                                                            setAiProfileMergeState({ keepId: profile.id, mergeId: otherId });
+                                                                    }, children: "Keep this" }))] }, profile.id))) }), aiProfileMergeState && selectedGroup.profiles.some((profile) => profile.id === aiProfileMergeState.keepId) && (_jsxs("div", { className: styles.aiProfileMergeActions, children: [_jsx("button", { className: styles.dangerBtn, onClick: () => { void handleMerge(aiProfileMergeState.keepId, aiProfileMergeState.mergeId); }, children: "Merge duplicates" }), _jsx("button", { className: styles.secondaryHeaderBtn, onClick: () => setAiProfileMergeState(null), children: "Cancel" })] }))] })] }) }))] })), aiProfileMergeStatus && (_jsxs("div", { className: `${aiProfileMergeStatus.type === 'success' ? styles.successMessage : styles.errorMessage} ${styles.marginTop12}`, children: [aiProfileMergeStatus.type === 'success' ? _jsx(Check, { size: 14 }) : _jsx(AlertTriangle, { size: 14 }), aiProfileMergeStatus.message] }))] }) }) }) }));
+}

package/dist/components/features/AgentsModule.test.js

@@ -0,0 +1,102 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { AgentsModule } from './AgentsModule';
+describe('AgentsModule', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('groups registered AI profiles by surface type in a stable section order', async () => {
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                assignees: [
+                    { value: 'member-1', label: 'Member One', kind: 'member' },
+                    {
+                        value: 'ai-chatgpt',
+                        label: 'ChatGPT',
+                        username: 'chatgpt',
+                        icon: 'Bot',
+                        color: '#10a37f',
+                        kind: 'agent',
+                        surfaceType: 'chat_app',
+                        description: 'General-purpose chat surface for planning and writing.',
+                        role: 'Product copilot',
+                        provider: 'OpenAI',
+                        model: 'gpt-5.4',
+                        createdAt: '2026-04-01T12:00:00.000Z',
+                        updatedAt: '2026-04-03T15:30:00.000Z',
+                        lastActiveAt: '2026-04-04T10:00:00.000Z'
+                    },
+                    {
+                        value: 'ai-codex-1',
+                        label: 'Codex',
+                        username: 'codex',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        kind: 'agent',
+                        surfaceType: 'coding_tool',
+                        description: 'Terminal-first coding agent.',
+                        role: 'Implementation partner',
+                        provider: 'OpenAI',
+                        model: 'gpt-5-codex',
+                        createdAt: '2026-04-02T09:00:00.000Z',
+                        updatedAt: '2026-04-04T13:15:00.000Z',
+                        lastActiveAt: '2026-04-04T13:45:00.000Z'
+                    },
+                    {
+                        value: 'ai-codex-2',
+                        label: 'Codex',
+                        username: 'codex-duplicate',
+                        icon: 'Bot',
+                        color: '#0ea5e9',
+                        kind: 'agent',
+                        surfaceType: 'coding_tool',
+                        description: 'Duplicate Codex profile.',
+                        role: 'Implementation partner',
+                        provider: 'OpenAI',
+                        model: 'gpt-5-codex',
+                        createdAt: '2026-04-02T10:00:00.000Z',
+                        updatedAt: '2026-04-04T13:16:00.000Z',
+                        lastActiveAt: '2026-04-04T13:46:00.000Z'
+                    },
+                    {
+                        value: 'ai-john',
+                        label: 'John Drake',
+                        username: 'john-drake',
+                        icon: 'Bot',
+                        color: '#64748b',
+                        kind: 'agent',
+                        surfaceType: null,
+                        createdAt: '2026-03-28T08:00:00.000Z',
+                        updatedAt: '2026-04-01T08:00:00.000Z',
+                        lastActiveAt: null
+                    }
+                ]
+            })
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { container } = render(_jsx(AgentsModule, { workspaceId: "workspace-1" }));
+        await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1));
+        expect((await screen.findAllByText('Chat Apps')).length).toBeGreaterThan(0);
+        expect(screen.getAllByText('Coding Tools').length).toBeGreaterThan(0);
+        expect(screen.getByText('Unclassified')).toBeInTheDocument();
+        expect(screen.getAllByText('Codex')).toHaveLength(1);
+        expect(screen.getByText(/2 duplicates/i)).toBeInTheDocument();
+        expect(screen.getByText('Coding tool')).toBeInTheDocument();
+        expect(screen.getAllByText('General-purpose chat surface for planning and writing.').length).toBeGreaterThan(0);
+        expect(screen.getAllByText('Product copilot').length).toBeGreaterThan(0);
+        expect(screen.getByText('OpenAI · gpt-5.4')).toBeInTheDocument();
+        expect(screen.getByText(/Profile instances/i)).toBeInTheDocument();
+        const text = container.textContent || '';
+        expect(text.indexOf('Chat Apps')).toBeLessThan(text.indexOf('Coding Tools'));
+        expect(text.indexOf('Coding Tools')).toBeLessThan(text.indexOf('Unclassified'));
+        fireEvent.click(screen.getByRole('button', { name: /codex/i }));
+        expect(screen.getAllByText('Terminal-first coding agent.').length).toBeGreaterThan(0);
+        expect(screen.getAllByText('Implementation partner')[0]).toBeInTheDocument();
+        expect(screen.getByText('OpenAI · gpt-5-codex')).toBeInTheDocument();
+        expect(screen.getByText(/2 linked profiles/i)).toBeInTheDocument();
+        expect(screen.getAllByTitle('Keep this profile, merge others into it')).toHaveLength(2);
+        expect(screen.getByText('@codex-duplicate')).toBeInTheDocument();
+    });
+});