@vibescope/mcp-server 0.2.0 → 0.2.1

package/dist/handlers/organizations.js

@@ -16,16 +16,71 @@
  * - unshare_project
  * - list_project_shares
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator, ValidationError } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 // Valid roles in order of permission level
 const ROLE_ORDER = ['viewer', 'member', 'admin', 'owner'];
+const ASSIGNABLE_ROLES = ['viewer', 'member', 'admin'];
 // Valid share permissions
 const PERMISSION_ORDER = ['read', 'write', 'admin'];
 // ============================================================================
+// Argument Schemas
+// ============================================================================
+const createOrganizationSchema = {
+    name: { type: 'string', required: true },
+    description: { type: 'string' },
+    slug: { type: 'string' },
+};
+const updateOrganizationSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    name: { type: 'string' },
+    description: { type: 'string' },
+    logo_url: { type: 'string' },
+};
+const deleteOrganizationSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const listOrgMembersSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const inviteMemberSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    email: { type: 'string', required: true },
+    role: { type: 'string', default: 'member', validate: createEnumValidator(ASSIGNABLE_ROLES) },
+};
+const updateMemberRoleSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    user_id: { type: 'string', required: true, validate: uuidValidator },
+    role: { type: 'string', required: true, validate: createEnumValidator(ROLE_ORDER) },
+};
+const removeMemberSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    user_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const leaveOrganizationSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const shareProjectWithOrgSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    permission: { type: 'string', default: 'read', validate: createEnumValidator(PERMISSION_ORDER) },
+};
+const updateProjectShareSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    permission: { type: 'string', required: true, validate: createEnumValidator(PERMISSION_ORDER) },
+};
+const unshareProjectSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const listProjectSharesSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+// ============================================================================
 // Organization Management
 // ============================================================================
-export const listOrganizations = async (_args, ctx) => {
+export const listOrganizations = async (_args, _ctx) => {
     const apiClient = getApiClient();
     const response = await apiClient.listOrganizations();
     if (!response.ok) {
@@ -33,9 +88,8 @@ export const listOrganizations = async (_args, ctx) => {
     }
     return { result: response.data };
 };
-export const createOrganization = async (args, ctx) => {
-    const { name, description, slug } = args;
-    validateRequired(name, 'name');
+export const createOrganization = async (args, _ctx) => {
+    const { name, description, slug } = parseArgs(args, createOrganizationSchema);
     const apiClient = getApiClient();
     const response = await apiClient.createOrganization({
         name,
@@ -47,10 +101,12 @@ export const createOrganization = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const updateOrganization = async (args, ctx) => {
-    const { organization_id, name, description, logo_url } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(organization_id, 'organization_id');
+export const updateOrganization = async (args, _ctx) => {
+    const { organization_id, name, description, logo_url } = parseArgs(args, updateOrganizationSchema);
+    // Check that at least one update is provided
+    if (name === undefined && description === undefined && logo_url === undefined) {
+        throw new ValidationError('No updates provided');
+    }
     const updates = {};
     if (name !== undefined)
         updates.name = name;
@@ -58,9 +114,6 @@ export const updateOrganization = async (args, ctx) => {
         updates.description = description;
     if (logo_url !== undefined)
         updates.logo_url = logo_url;
-    if (Object.keys(updates).length === 0) {
-        throw new Error('No updates provided');
-    }
     const apiClient = getApiClient();
     const response = await apiClient.updateOrganization(organization_id, updates);
     if (!response.ok) {
@@ -68,10 +121,8 @@ export const updateOrganization = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const deleteOrganization = async (args, ctx) => {
-    const { organization_id } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(organization_id, 'organization_id');
+export const deleteOrganization = async (args, _ctx) => {
+    const { organization_id } = parseArgs(args, deleteOrganizationSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteOrganization(organization_id);
     if (!response.ok) {
@@ -82,10 +133,8 @@ export const deleteOrganization = async (args, ctx) => {
 // ============================================================================
 // Member Management
 // ============================================================================
-export const listOrgMembers = async (args, ctx) => {
-    const { organization_id } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(organization_id, 'organization_id');
+export const listOrgMembers = async (args, _ctx) => {
+    const { organization_id } = parseArgs(args, listOrgMembersSchema);
     const apiClient = getApiClient();
     const response = await apiClient.listOrgMembers(organization_id);
     if (!response.ok) {
@@ -93,14 +142,8 @@ export const listOrgMembers = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const inviteMember = async (args, ctx) => {
-    const { organization_id, email, role = 'member' } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateRequired(email, 'email');
-    validateUUID(organization_id, 'organization_id');
-    if (!['admin', 'member', 'viewer'].includes(role)) {
-        throw new Error('Invalid role. Must be admin, member, or viewer.');
-    }
+export const inviteMember = async (args, _ctx) => {
+    const { organization_id, email, role } = parseArgs(args, inviteMemberSchema);
     const apiClient = getApiClient();
     const response = await apiClient.inviteMember(organization_id, email, role);
     if (!response.ok) {
@@ -108,18 +151,10 @@ export const inviteMember = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const updateMemberRole = async (args, ctx) => {
-    const { organization_id, user_id, role } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateRequired(user_id, 'user_id');
-    validateRequired(role, 'role');
-    validateUUID(organization_id, 'organization_id');
-    validateUUID(user_id, 'user_id');
-    if (!ROLE_ORDER.includes(role)) {
-        throw new Error(`Invalid role. Must be one of: ${ROLE_ORDER.join(', ')}`);
-    }
+export const updateMemberRole = async (args, _ctx) => {
+    const { organization_id, user_id, role } = parseArgs(args, updateMemberRoleSchema);
     if (role === 'owner') {
-        throw new Error('Cannot assign owner role. Use transfer ownership instead.');
+        throw new ValidationError('Cannot assign owner role. Use transfer ownership instead.');
     }
     const apiClient = getApiClient();
     const response = await apiClient.updateMemberRole(organization_id, user_id, role);
@@ -128,12 +163,8 @@ export const updateMemberRole = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const removeMember = async (args, ctx) => {
-    const { organization_id, user_id } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateRequired(user_id, 'user_id');
-    validateUUID(organization_id, 'organization_id');
-    validateUUID(user_id, 'user_id');
+export const removeMember = async (args, _ctx) => {
+    const { organization_id, user_id } = parseArgs(args, removeMemberSchema);
     const apiClient = getApiClient();
     const response = await apiClient.removeMember(organization_id, user_id);
     if (!response.ok) {
@@ -141,10 +172,8 @@ export const removeMember = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const leaveOrganization = async (args, ctx) => {
-    const { organization_id } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(organization_id, 'organization_id');
+export const leaveOrganization = async (args, _ctx) => {
+    const { organization_id } = parseArgs(args, leaveOrganizationSchema);
     const apiClient = getApiClient();
     const response = await apiClient.leaveOrganization(organization_id);
     if (!response.ok) {
@@ -155,15 +184,8 @@ export const leaveOrganization = async (args, ctx) => {
 // ============================================================================
 // Project Sharing
 // ============================================================================
-export const shareProjectWithOrg = async (args, ctx) => {
-    const { project_id, organization_id, permission = 'read' } = args;
-    validateRequired(project_id, 'project_id');
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(project_id, 'project_id');
-    validateUUID(organization_id, 'organization_id');
-    if (!PERMISSION_ORDER.includes(permission)) {
-        throw new Error(`Invalid permission. Must be one of: ${PERMISSION_ORDER.join(', ')}`);
-    }
+export const shareProjectWithOrg = async (args, _ctx) => {
+    const { project_id, organization_id, permission } = parseArgs(args, shareProjectWithOrgSchema);
     const apiClient = getApiClient();
     const response = await apiClient.shareProjectWithOrg(project_id, organization_id, permission);
     if (!response.ok) {
@@ -171,16 +193,8 @@ export const shareProjectWithOrg = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const updateProjectShare = async (args, ctx) => {
-    const { project_id, organization_id, permission } = args;
-    validateRequired(project_id, 'project_id');
-    validateRequired(organization_id, 'organization_id');
-    validateRequired(permission, 'permission');
-    validateUUID(project_id, 'project_id');
-    validateUUID(organization_id, 'organization_id');
-    if (!PERMISSION_ORDER.includes(permission)) {
-        throw new Error(`Invalid permission. Must be one of: ${PERMISSION_ORDER.join(', ')}`);
-    }
+export const updateProjectShare = async (args, _ctx) => {
+    const { project_id, organization_id, permission } = parseArgs(args, updateProjectShareSchema);
     const apiClient = getApiClient();
     const response = await apiClient.updateProjectShare(project_id, organization_id, permission);
     if (!response.ok) {
@@ -188,12 +202,8 @@ export const updateProjectShare = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const unshareProject = async (args, ctx) => {
-    const { project_id, organization_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(project_id, 'project_id');
-    validateUUID(organization_id, 'organization_id');
+export const unshareProject = async (args, _ctx) => {
+    const { project_id, organization_id } = parseArgs(args, unshareProjectSchema);
     const apiClient = getApiClient();
     const response = await apiClient.unshareProject(project_id, organization_id);
     if (!response.ok) {
@@ -201,10 +211,8 @@ export const unshareProject = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const listProjectShares = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+export const listProjectShares = async (args, _ctx) => {
+    const { project_id } = parseArgs(args, listProjectSharesSchema);
     const apiClient = getApiClient();
     const response = await apiClient.listProjectShares(project_id);
     if (!response.ok) {

package/dist/handlers/progress.js

@@ -7,13 +7,24 @@
  *
  * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+// Argument schemas for type-safe parsing
+const logProgressSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    task_id: { type: 'string', validate: uuidValidator },
+    summary: { type: 'string', required: true },
+    details: { type: 'string' },
+};
+const getActivityFeedSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    limit: { type: 'number', default: 50 },
+    since: { type: 'string' },
+    types: { type: 'array' },
+    created_by: { type: 'string' },
+};
 export const logProgress = async (args, ctx) => {
-    const { project_id, task_id, summary, details } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(summary, 'summary');
+    const { project_id, task_id, summary, details } = parseArgs(args, logProgressSchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.logProgress(project_id, {
@@ -27,15 +38,15 @@ export const logProgress = async (args, ctx) => {
     }
     return { result: { success: true, progress_id: response.data?.progress_id } };
 };
-export const getActivityFeed = async (args, ctx) => {
-    const { project_id, limit = 50, since } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+export const getActivityFeed = async (args, _ctx) => {
+    const { project_id, limit, since, types, created_by } = parseArgs(args, getActivityFeedSchema);
     const apiClient = getApiClient();
-    const effectiveLimit = Math.min(limit, 200);
+    const effectiveLimit = Math.min(limit ?? 50, 200);
     const response = await apiClient.getActivityFeed(project_id, {
         limit: effectiveLimit,
-        since
+        since,
+        types: types,
+        created_by
     });
     if (!response.ok) {
         throw new Error(`Failed to fetch activity feed: ${response.error}`);

package/dist/handlers/project.js

@@ -8,10 +8,46 @@
  * - update_project
  * - update_project_readme
  */
-import { validateRequired, validateUUID, validateProjectStatus } from '../validators.js';
+import { parseArgs, uuidValidator, projectStatusValidator, createEnumValidator, } from '../validators.js';
 import { getApiClient } from '../api-client.js';
-export const getProjectContext = async (args, ctx) => {
-    const { project_id, git_url } = args;
+const VALID_GIT_WORKFLOWS = ['none', 'trunk-based', 'github-flow', 'git-flow'];
+// Argument schemas for type-safe parsing
+const getProjectContextSchema = {
+    project_id: { type: 'string', validate: uuidValidator },
+    git_url: { type: 'string' },
+};
+const getGitWorkflowSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    task_id: { type: 'string', validate: uuidValidator },
+};
+const createProjectSchema = {
+    name: { type: 'string', required: true },
+    description: { type: 'string' },
+    goal: { type: 'string' },
+    git_url: { type: 'string' },
+    tech_stack: { type: 'array' },
+};
+const updateProjectSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    name: { type: 'string' },
+    description: { type: 'string' },
+    goal: { type: 'string' },
+    git_url: { type: 'string' },
+    tech_stack: { type: 'array' },
+    status: { type: 'string', validate: projectStatusValidator },
+    git_workflow: { type: 'string', validate: createEnumValidator(VALID_GIT_WORKFLOWS) },
+    git_main_branch: { type: 'string' },
+    git_develop_branch: { type: 'string' },
+    git_auto_branch: { type: 'boolean' },
+    git_auto_tag: { type: 'boolean' },
+    deployment_instructions: { type: 'string' },
+};
+const updateProjectReadmeSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    readme_content: { type: 'string', required: true },
+};
+export const getProjectContext = async (args, _ctx) => {
+    const { project_id, git_url } = parseArgs(args, getProjectContextSchema);
     const apiClient = getApiClient();
     // If no project_id or git_url, list all projects
     if (!project_id && !git_url) {
@@ -36,10 +72,8 @@ export const getProjectContext = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const getGitWorkflow = async (args, ctx) => {
-    const { project_id, task_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+export const getGitWorkflow = async (args, _ctx) => {
+    const { project_id, task_id } = parseArgs(args, getGitWorkflowSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getGitWorkflow(project_id, task_id);
     if (!response.ok) {
@@ -47,39 +81,45 @@ export const getGitWorkflow = async (args, ctx) => {
     }
     return { result: response.data };
 };
-export const createProject = async (args, ctx) => {
-    const { name, description, goal, git_url, tech_stack } = args;
-    validateRequired(name, 'name');
+export const createProject = async (args, _ctx) => {
+    const { name, description, goal, git_url, tech_stack } = parseArgs(args, createProjectSchema);
     const apiClient = getApiClient();
     const response = await apiClient.createProject({
         name,
         description,
         goal,
         git_url,
-        tech_stack
+        tech_stack: tech_stack
     });
     if (!response.ok) {
         throw new Error(response.error || 'Failed to create project');
     }
     return { result: response.data };
 };
-export const updateProject = async (args, ctx) => {
-    const { project_id, ...updates } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateProjectStatus(updates.status);
+export const updateProject = async (args, _ctx) => {
+    const { project_id, name, description, goal, git_url, tech_stack, status, git_workflow, git_main_branch, git_develop_branch, git_auto_branch, git_auto_tag, deployment_instructions } = parseArgs(args, updateProjectSchema);
     const apiClient = getApiClient();
-    const response = await apiClient.updateProject(project_id, updates);
+    const response = await apiClient.updateProject(project_id, {
+        name,
+        description,
+        goal,
+        git_url,
+        tech_stack: tech_stack,
+        status: status,
+        git_workflow: git_workflow,
+        git_main_branch,
+        git_develop_branch,
+        git_auto_branch,
+        git_auto_tag,
+        deployment_instructions
+    });
     if (!response.ok) {
         throw new Error(response.error || 'Failed to update project');
     }
     return { result: response.data };
 };
-export const updateProjectReadme = async (args, ctx) => {
-    const { project_id, readme_content } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(readme_content, 'readme_content');
+export const updateProjectReadme = async (args, _ctx) => {
+    const { project_id, readme_content } = parseArgs(args, updateProjectReadmeSchema);
     const apiClient = getApiClient();
     const response = await apiClient.updateProjectReadme(project_id, readme_content);
     if (!response.ok) {

package/dist/handlers/requests.js

@@ -8,12 +8,21 @@
  *
  * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+// Argument schemas for type-safe parsing
+const getPendingRequestsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const acknowledgeRequestSchema = {
+    request_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const answerQuestionSchema = {
+    request_id: { type: 'string', required: true, validate: uuidValidator },
+    answer: { type: 'string', required: true },
+};
 export const getPendingRequests = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id } = parseArgs(args, getPendingRequestsSchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.getPendingRequests(project_id, session.currentSessionId || undefined);
@@ -28,9 +37,7 @@ export const getPendingRequests = async (args, ctx) => {
     };
 };
 export const acknowledgeRequest = async (args, ctx) => {
-    const { request_id } = args;
-    validateRequired(request_id, 'request_id');
-    validateUUID(request_id, 'request_id');
+    const { request_id } = parseArgs(args, acknowledgeRequestSchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.acknowledgeRequest(request_id, session.currentSessionId || undefined);
@@ -44,10 +51,7 @@ export const acknowledgeRequest = async (args, ctx) => {
     };
 };
 export const answerQuestion = async (args, ctx) => {
-    const { request_id, answer } = args;
-    validateRequired(request_id, 'request_id');
-    validateRequired(answer, 'answer');
-    validateUUID(request_id, 'request_id');
+    const { request_id, answer } = parseArgs(args, answerQuestionSchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.answerQuestion(request_id, answer, session.currentSessionId || undefined);

package/dist/handlers/roles.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Role Management Handlers
+ *
+ * Handles agent role configuration and assignment:
+ * - get_role_settings: Get role configuration for a project
+ * - update_role_settings: Update role settings for a project
+ * - set_session_role: Set the role for the current session
+ * - get_agents_by_role: Get active agents grouped by their assigned roles
+ */
+import type { Handler, HandlerRegistry } from './types.js';
+export declare const getRoleSettings: Handler;
+export declare const updateRoleSettings: Handler;
+export declare const setSessionRole: Handler;
+export declare const getAgentsByRole: Handler;
+/**
+ * Role handlers registry
+ */
+export declare const roleHandlers: HandlerRegistry;

package/dist/handlers/roles.js

@@ -0,0 +1,130 @@
+/**
+ * Role Management Handlers
+ *
+ * Handles agent role configuration and assignment:
+ * - get_role_settings: Get role configuration for a project
+ * - update_role_settings: Update role settings for a project
+ * - set_session_role: Set the role for the current session
+ * - get_agents_by_role: Get active agents grouped by their assigned roles
+ */
+import { getApiClient } from '../api-client.js';
+export const getRoleSettings = async (args, _ctx) => {
+    const { project_id } = args;
+    if (!project_id) {
+        return {
+            result: { error: 'project_id is required' },
+        };
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('get_role_settings', { project_id });
+    if (!response.ok) {
+        return {
+            result: { error: response.error || 'Failed to get role settings' },
+        };
+    }
+    return { result: response.data };
+};
+export const updateRoleSettings = async (args, _ctx) => {
+    const { project_id, role, enabled, display_name, description, priority_filter, fallback_activities, auto_assign_validation, auto_assign_deployment, } = args;
+    if (!project_id) {
+        return {
+            result: { error: 'project_id is required' },
+        };
+    }
+    if (!role) {
+        return {
+            result: { error: 'role is required' },
+        };
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('update_role_settings', {
+        project_id,
+        role,
+        enabled,
+        display_name,
+        description,
+        priority_filter,
+        fallback_activities,
+        auto_assign_validation,
+        auto_assign_deployment,
+    });
+    if (!response.ok) {
+        return {
+            result: { error: response.error || 'Failed to update role settings' },
+        };
+    }
+    return { result: response.data };
+};
+export const setSessionRole = async (args, ctx) => {
+    const { role, role_config } = args;
+    const { session, updateSession } = ctx;
+    if (!role) {
+        return {
+            result: { error: 'role is required' },
+        };
+    }
+    const validRoles = ['developer', 'validator', 'deployer', 'reviewer', 'maintainer'];
+    if (!validRoles.includes(role)) {
+        return {
+            result: {
+                error: `Invalid role: ${role}. Must be one of: ${validRoles.join(', ')}`,
+            },
+        };
+    }
+    // Update local session state
+    updateSession({ currentRole: role });
+    // If there's an active session, update it on the server too
+    if (session.currentSessionId) {
+        const apiClient = getApiClient();
+        const response = await apiClient.proxy('set_session_role', {
+            session_id: session.currentSessionId,
+            role,
+            role_config,
+        });
+        if (!response.ok) {
+            return {
+                result: { error: response.error || 'Failed to update session role' },
+            };
+        }
+        return {
+            result: {
+                success: true,
+                session_id: session.currentSessionId,
+                role,
+                message: `Session role updated to ${role}. Task filtering and fallback suggestions will now be optimized for this role.`,
+            },
+        };
+    }
+    return {
+        result: {
+            success: true,
+            role,
+            message: `Local role set to ${role}. Start a session to persist this role.`,
+        },
+    };
+};
+export const getAgentsByRole = async (args, _ctx) => {
+    const { project_id } = args;
+    if (!project_id) {
+        return {
+            result: { error: 'project_id is required' },
+        };
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.proxy('get_agents_by_role', { project_id });
+    if (!response.ok) {
+        return {
+            result: { error: response.error || 'Failed to get agents by role' },
+        };
+    }
+    return { result: response.data };
+};
+/**
+ * Role handlers registry
+ */
+export const roleHandlers = {
+    get_role_settings: getRoleSettings,
+    update_role_settings: updateRoleSettings,
+    set_session_role: setSessionRole,
+    get_agents_by_role: getAgentsByRole,
+};