wolfpack-mcp 1.0.90 → 1.0.92

package/dist/agentBuilderTools.js

@@ -113,6 +113,10 @@ export const AGENT_BUILDER_TOOLS = [
                     items: { type: 'string' },
                     description: 'Replace the full set of MCP permissions granted to the agent\'s session API key (e.g. ["mcp:work_items:read", "mcp:comments:create"]). Grant only what the agent\'s tasks need. An empty array falls back to a read-only default.',
                 },
+                scheduling_enabled: {
+                    type: 'boolean',
+                    description: "The agent-level scheduling switch. No schedule fires while it is off, whatever the schedule's own enabled flag says.",
+                },
                 ...ORG_SLUG_PROP,
             },
             required: ['agent_id'],
@@ -532,6 +536,23 @@ export const AGENT_BUILDER_TOOLS = [
                     description: 'When true, tasks run once with access to all assigned projects. ' +
                         'When false, tasks run once per project.',
                 },
+                preflight_check: {
+                    type: 'string',
+                    enum: ['claimable-work', 'claimable-check'],
+                    description: 'LLM-free condition evaluated when the schedule fires; a false result skips the fire with no session and no cost. ' +
+                        '"claimable-work": an approved, unclaimed item is assigned to the agent or sits in one of its work pools. ' +
+                        '"claimable-check": a pending, unclaimed review check sits on an item in one of its pools. Null to clear.',
+                },
+                check_kinds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'With "claimable-check": only checks of these kinds wake the schedule (e.g. ["security-review"]), so reviewers ' +
+                        'sharing a pool each answer their own kind. Empty for every kind.',
+                },
+                skip_while_active: {
+                    type: 'boolean',
+                    description: 'Skip a fire entirely while the agent still has a queued or running task, or leads an item awaiting review.',
+                },
                 task_ids: {
                     type: 'array',
                     items: { type: 'string' },
@@ -575,6 +596,23 @@ export const AGENT_BUILDER_TOOLS = [
                     type: 'boolean',
                     description: 'Run once across all projects (true) or once per project (false)',
                 },
+                preflight_check: {
+                    type: 'string',
+                    enum: ['claimable-work', 'claimable-check'],
+                    description: 'LLM-free condition evaluated when the schedule fires; a false result skips the fire with no session and no cost. ' +
+                        '"claimable-work": an approved, unclaimed item is assigned to the agent or sits in one of its work pools. ' +
+                        '"claimable-check": a pending, unclaimed review check sits on an item in one of its pools. Null to clear.',
+                },
+                check_kinds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'With "claimable-check": only checks of these kinds wake the schedule (e.g. ["security-review"]), so reviewers ' +
+                        'sharing a pool each answer their own kind. Empty for every kind.',
+                },
+                skip_while_active: {
+                    type: 'boolean',
+                    description: 'Skip a fire entirely while the agent still has a queued or running task, or leads an item awaiting review.',
+                },
                 task_ids: {
                     type: 'array',
                     items: { type: 'string' },
@@ -798,6 +836,19 @@ const AgentTaskSchema = z.object({
     org_slug: orgSlugField,
 });
 const SkillIdSchema = z.object({ skill_id: z.string(), org_slug: orgSlugField });
+/**
+ * A schedule enabled on an agent whose own scheduling switch is off never
+ * fires (#2083) — say so in the result rather than letting the caller find
+ * out from a schedule that stays silent.
+ */
+async function schedulingOffWarning(client, agentId, scheduleEnabled, orgSlug) {
+    if (!scheduleEnabled)
+        return '';
+    const agent = await client.getAgent(agentId, orgSlug);
+    return !agent || agent.schedulingEnabled
+        ? ''
+        : "\n\nWARNING: this agent's scheduling is switched off, so the schedule will not fire until update_agent sets scheduling_enabled: true.";
+}
 export async function handleAgentBuilderTool(name, args, client) {
     const text = (t) => JSON.stringify(t, null, 2);
     switch (name) {
@@ -855,6 +906,7 @@ export async function handleAgentBuilderTool(name, args, client) {
                 llm_model: z.string().nullable().optional(),
                 llm_family: z.string().nullable().optional(),
                 api_key_permissions: z.array(z.string()).optional(),
+                scheduling_enabled: z.boolean().optional(),
                 org_slug: orgSlugField,
             })
                 .parse(args);
@@ -878,6 +930,8 @@ export async function handleAgentBuilderTool(name, args, client) {
                 fields.llmFamily = rest.llm_family;
             if (rest.api_key_permissions !== undefined)
                 fields.apiKeyPermissions = rest.api_key_permissions;
+            if (rest.scheduling_enabled !== undefined)
+                fields.schedulingEnabled = rest.scheduling_enabled;
             const agent = await client.updateAgent(agent_id, fields, resolveOrg(parsed));
             return { content: [{ type: 'text', text: `Updated agent\n\n${text(agent)}` }] };
         }
@@ -1166,6 +1220,9 @@ export async function handleAgentBuilderTool(name, args, client) {
                 timezone: z.string().optional(),
                 dst_aware: z.boolean().optional(),
                 multi_project: z.boolean().optional(),
+                preflight_check: z.enum(['claimable-work', 'claimable-check']).nullable().optional(),
+                check_kinds: z.array(z.string()).optional(),
+                skip_while_active: z.boolean().optional(),
                 task_ids: z.array(z.string()).optional(),
                 org_slug: orgSlugField,
             })
@@ -1190,12 +1247,22 @@ export async function handleAgentBuilderTool(name, args, client) {
                 body.dstAware = rest.dst_aware;
             if (rest.multi_project !== undefined)
                 body.multiProject = rest.multi_project;
+            if (rest.preflight_check !== undefined)
+                body.preflightCheck = rest.preflight_check;
+            if (rest.check_kinds !== undefined)
+                body.checkKinds = rest.check_kinds;
+            if (rest.skip_while_active !== undefined)
+                body.skipWhileActive = rest.skip_while_active;
             if (rest.task_ids !== undefined)
                 body.taskIds = rest.task_ids;
             const schedule = await client.createAgentSchedule(agent_id, body, resolveOrg(parsed));
+            const warning = await schedulingOffWarning(client, agent_id, schedule.enabled, resolveOrg(parsed));
             return {
                 content: [
-                    { type: 'text', text: `Created schedule "${schedule.name}"\n\n${text(schedule)}` },
+                    {
+                        type: 'text',
+                        text: `Created schedule "${schedule.name}"${warning}\n\n${text(schedule)}`,
+                    },
                 ],
             };
         }
@@ -1213,6 +1280,9 @@ export async function handleAgentBuilderTool(name, args, client) {
                 timezone: z.string().optional(),
                 dst_aware: z.boolean().optional(),
                 multi_project: z.boolean().optional(),
+                preflight_check: z.enum(['claimable-work', 'claimable-check']).nullable().optional(),
+                check_kinds: z.array(z.string()).optional(),
+                skip_while_active: z.boolean().optional(),
                 task_ids: z.array(z.string()).optional(),
                 org_slug: orgSlugField,
             })
@@ -1237,10 +1307,19 @@ export async function handleAgentBuilderTool(name, args, client) {
                 body.dstAware = rest.dst_aware;
             if (rest.multi_project !== undefined)
                 body.multiProject = rest.multi_project;
+            if (rest.preflight_check !== undefined)
+                body.preflightCheck = rest.preflight_check;
+            if (rest.check_kinds !== undefined)
+                body.checkKinds = rest.check_kinds;
+            if (rest.skip_while_active !== undefined)
+                body.skipWhileActive = rest.skip_while_active;
             if (rest.task_ids !== undefined)
                 body.taskIds = rest.task_ids;
             const schedule = await client.updateAgentSchedule(agent_id, schedule_id, body, resolveOrg(parsed));
-            return { content: [{ type: 'text', text: `Updated schedule\n\n${text(schedule)}` }] };
+            const warning = await schedulingOffWarning(client, agent_id, schedule.enabled, resolveOrg(parsed));
+            return {
+                content: [{ type: 'text', text: `Updated schedule${warning}\n\n${text(schedule)}` }],
+            };
         }
         // ─── Skills ─────────────────────────────────────────────────────────────
         case 'create_skill': {

package/dist/agentBuilderTools.test.js

@@ -98,3 +98,68 @@ describe('extra instructions on a task run over MCP (#2048)', () => {
         expect(runAgentTask.mock.calls[0][6]).toBeUndefined();
     });
 });
+// #2083: everything the schedule editor can set is settable over MCP, and a
+// schedule enabled on an agent whose scheduling switch is off says so.
+describe('schedule pre-flight and scheduling switch over MCP (#2083)', () => {
+    const SCHEDULE_FIELDS = ['preflight_check', 'check_kinds', 'skip_while_active'];
+    it.each(['create_agent_schedule', 'update_agent_schedule'])('%s advertises the pre-flight fields', (name) => {
+        const properties = toolNamed(name).inputSchema.properties;
+        expect(Object.keys(properties)).toEqual(expect.arrayContaining(SCHEDULE_FIELDS));
+    });
+    it('update_agent advertises the scheduling switch', () => {
+        const properties = toolNamed('update_agent').inputSchema.properties;
+        expect(Object.keys(properties)).toContain('scheduling_enabled');
+    });
+    function scheduleClient(schedulingEnabled) {
+        const schedule = { id: 'sched-1', name: 'Reviews', enabled: true };
+        const createAgentSchedule = vi.fn().mockResolvedValue(schedule);
+        const updateAgentSchedule = vi.fn().mockResolvedValue(schedule);
+        const updateAgent = vi.fn().mockResolvedValue({ id: 'agent-1', schedulingEnabled });
+        const getAgent = vi.fn().mockResolvedValue({ id: 'agent-1', schedulingEnabled });
+        return {
+            client: {
+                createAgentSchedule,
+                updateAgentSchedule,
+                updateAgent,
+                getAgent,
+            },
+            createAgentSchedule,
+            updateAgentSchedule,
+            updateAgent,
+        };
+    }
+    it('sends the pre-flight, kinds and skip-while-active when creating a schedule', async () => {
+        const { client, createAgentSchedule } = scheduleClient(true);
+        await handleAgentBuilderTool('create_agent_schedule', {
+            agent_id: 'agent-1',
+            preflight_check: 'claimable-check',
+            check_kinds: ['security-review'],
+            skip_while_active: true,
+        }, client);
+        expect(createAgentSchedule.mock.calls[0][1]).toMatchObject({
+            preflightCheck: 'claimable-check',
+            checkKinds: ['security-review'],
+            skipWhileActive: true,
+        });
+    });
+    it('sends the same fields when updating a schedule', async () => {
+        const { client, updateAgentSchedule } = scheduleClient(true);
+        await handleAgentBuilderTool('update_agent_schedule', { agent_id: 'agent-1', schedule_id: 'sched-1', preflight_check: null, check_kinds: [] }, client);
+        expect(updateAgentSchedule.mock.calls[0][2]).toEqual({ preflightCheck: null, checkKinds: [] });
+    });
+    it('sends the scheduling switch when updating an agent', async () => {
+        const { client, updateAgent } = scheduleClient(true);
+        await handleAgentBuilderTool('update_agent', { agent_id: 'agent-1', scheduling_enabled: true }, client);
+        expect(updateAgent.mock.calls[0][1]).toEqual({ schedulingEnabled: true });
+    });
+    it('warns when an enabled schedule lands on an agent whose scheduling is off', async () => {
+        const { client } = scheduleClient(false);
+        const result = await handleAgentBuilderTool('create_agent_schedule', { agent_id: 'agent-1', enabled: true }, client);
+        expect(result.content[0].text).toContain('scheduling is switched off');
+    });
+    it('stays quiet when the agent is scheduling', async () => {
+        const { client } = scheduleClient(true);
+        const result = await handleAgentBuilderTool('create_agent_schedule', { agent_id: 'agent-1', enabled: true }, client);
+        expect(result.content[0].text).not.toContain('WARNING');
+    });
+});

package/dist/client.js

@@ -247,9 +247,14 @@ export class WolfpackClient {
             params.set('workItemId', filter.workItemId);
         if (filter.status)
             params.set('status', filter.status);
+        if (filter.kind)
+            params.set('kind', filter.kind);
         const query = params.toString();
         return this.api.get(this.withTeamSlug(`/work-item-checks${query ? `?${query}` : ''}`, teamSlug));
     }
+    async addWorkItemCheck(workItemId, body, teamSlug) {
+        return this.api.post(this.withTeamSlug(`/work-items/${workItemId}/checks`, teamSlug), body);
+    }
     async claimWorkItemCheck(workItemId, checkId, teamSlug) {
         return this.api.post(this.withTeamSlug(`/work-items/${workItemId}/checks/${checkId}/claim`, teamSlug), {});
     }
@@ -502,6 +507,16 @@ export class WolfpackClient {
         const query = params.toString();
         return this.api.get(`/categories${query ? `?${query}` : ''}`);
     }
+    // Work pool methods (#2083)
+    async listWorkPools(teamSlug) {
+        return this.api.get(this.withTeamSlug('/work-pools', teamSlug));
+    }
+    async addWorkPoolMember(workPool, userId, teamSlug) {
+        return this.api.post(this.withTeamSlug(`/work-pools/${encodeURIComponent(workPool)}/members`, teamSlug), { userId });
+    }
+    async removeWorkPoolMember(workPool, userId, teamSlug) {
+        await this.api.delete(this.withTeamSlug(`/work-pools/${encodeURIComponent(workPool)}/members/${encodeURIComponent(userId)}`, teamSlug));
+    }
     // Tag methods
     async listTags(teamSlug) {
         const params = new URLSearchParams();

package/dist/index.js

@@ -215,11 +215,32 @@ const SubmitWorkItemFormSchema = z.object({
         .optional()
         .describe('Project slug (required for multi-project users, use list_projects to get slugs)'),
 });
+const WorkPoolMemberSchema = z.object({
+    work_pool: z.string().describe('Work pool id or name'),
+    user_id: z.string().describe('The user id to add or remove'),
+    project_slug: z
+        .string()
+        .optional()
+        .describe('Project slug (required for multi-project users, use list_projects to get slugs)'),
+});
 const ListWorkItemChecksSchema = z.object({
     work_item_id: refIdString()
         .optional()
         .describe('The refId of a work item; omit for your reviewer inbox'),
     status: z.enum(['pending', 'passed', 'failed']).optional().describe('Filter by check status'),
+    kind: z.string().optional().describe('Filter by check kind, e.g. code-review or security-review'),
+    project_slug: z
+        .string()
+        .optional()
+        .describe('Project slug (required for multi-project users, use list_projects to get slugs)'),
+});
+const AddWorkItemCheckSchema = z.object({
+    work_item_id: refIdString().describe('The refId of the work item'),
+    kind: z.string().describe('The check kind to add, e.g. security-review'),
+    comment: z
+        .string()
+        .optional()
+        .describe('Why the check is being requested — posted as a comment on the item'),
     project_slug: z
         .string()
         .optional()
@@ -1087,7 +1108,8 @@ class WolfpackMCPServer {
                             'Checks on blocked items are left out — blocked work is not picked up, and claiming one is refused. ' +
                             'REVIEW WORKFLOW: claim a check with claim_work_item_check, get_work_item to read the work, review it, ' +
                             'then complete_work_item_check with "passed" or "failed" and a short summary. ' +
-                            'A failed check sends the item back to its developer with your summary as feedback; do not change the item status yourself.',
+                            'A failed check sends the item back to its developer with your summary as feedback; do not change the item status yourself. ' +
+                            'To request a further review of another kind on an item (e.g. security-review), use add_work_item_check.',
                         inputSchema: {
                             type: 'object',
                             properties: {
@@ -1100,11 +1122,40 @@ class WolfpackMCPServer {
                                     enum: ['pending', 'passed', 'failed'],
                                     description: 'Filter by check status',
                                 },
+                                kind: {
+                                    type: 'string',
+                                    description: 'Filter by check kind (code-review, security-review, ...). A reviewer that answers one kind lists only that kind.',
+                                },
+                                project_slug: {
+                                    type: 'string',
+                                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                                },
+                            },
+                        },
+                    },
+                    {
+                        name: 'add_work_item_check',
+                        description: 'Add a pending review check of a kind (e.g. security-review) to a work item you do not lead, so the reviewer that answers that kind picks it up from its inbox. ' +
+                            "Use it when a change touches a sensitive path and needs a second, specialised review. A case waiting on the item's checks keeps waiting until the new check is resolved. " +
+                            'Refused for a kind already pending on the item, for person-only kinds, and on your own work.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                work_item_id: { type: 'string', description: 'The refId of the work item' },
+                                kind: {
+                                    type: 'string',
+                                    description: 'The check kind to add, e.g. security-review',
+                                },
+                                comment: {
+                                    type: 'string',
+                                    description: 'Why the check is being requested — posted as a comment on the item',
+                                },
                                 project_slug: {
                                     type: 'string',
                                     description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
                                 },
                             },
+                            required: ['work_item_id', 'kind'],
                         },
                     },
                     {
@@ -1837,6 +1888,52 @@ class WolfpackMCPServer {
                             },
                         },
                     },
+                    // Work pool tools (#2083)
+                    {
+                        name: 'list_work_pools',
+                        description: 'List the work pools in a project with their members. Reviewer and DevOps agents find their checks through pool membership, so this is how to see who is routed where.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                project_slug: {
+                                    type: 'string',
+                                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                                },
+                            },
+                        },
+                    },
+                    {
+                        name: 'add_work_pool_member',
+                        description: "Add a user or agent (by user id, e.g. an agent profile's userId) to a work pool, named by id or name. Requires mcp:agents:update.",
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                work_pool: { type: 'string', description: 'Work pool id or name' },
+                                user_id: { type: 'string', description: 'The user id to add' },
+                                project_slug: {
+                                    type: 'string',
+                                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                                },
+                            },
+                            required: ['work_pool', 'user_id'],
+                        },
+                    },
+                    {
+                        name: 'remove_work_pool_member',
+                        description: 'Remove a user or agent from a work pool. Requires mcp:agents:update.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                work_pool: { type: 'string', description: 'Work pool id or name' },
+                                user_id: { type: 'string', description: 'The user id to remove' },
+                                project_slug: {
+                                    type: 'string',
+                                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                                },
+                            },
+                            required: ['work_pool', 'user_id'],
+                        },
+                    },
                     // Tag tools
                     {
                         name: 'list_tags',
@@ -2439,7 +2536,7 @@ class WolfpackMCPServer {
                     case 'list_work_item_checks': {
                         const parsed = ListWorkItemChecksSchema.parse(args);
                         const teamSlug = parsed.project_slug || this.client.getProjectSlug() || undefined;
-                        const checks = await this.client.listWorkItemChecks({ workItemId: parsed.work_item_id, status: parsed.status }, teamSlug);
+                        const checks = await this.client.listWorkItemChecks({ workItemId: parsed.work_item_id, status: parsed.status, kind: parsed.kind }, teamSlug);
                         const text = checks.length === 0
                             ? parsed.work_item_id
                                 ? 'No review checks on this work item'
@@ -2447,6 +2544,19 @@ class WolfpackMCPServer {
                             : JSON.stringify(checks.map(formatWorkItemCheck), null, 2);
                         return { content: [{ type: 'text', text }] };
                     }
+                    case 'add_work_item_check': {
+                        const parsed = AddWorkItemCheckSchema.parse(args);
+                        const teamSlug = parsed.project_slug || this.client.getProjectSlug() || undefined;
+                        const check = await this.client.addWorkItemCheck(parsed.work_item_id, { kind: parsed.kind, comment: parsed.comment }, teamSlug);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Added ${check.kind} check to #${check.workItemRefId} "${check.workItemTitle}"\n\n${JSON.stringify(formatWorkItemCheck(check), null, 2)}`,
+                                },
+                            ],
+                        };
+                    }
                     case 'claim_work_item_check': {
                         const parsed = ClaimWorkItemCheckSchema.parse(args);
                         const teamSlug = parsed.project_slug || this.client.getProjectSlug() || undefined;
@@ -2938,6 +3048,36 @@ class WolfpackMCPServer {
                             content: [{ type: 'text', text: JSON.stringify(categories, null, 2) }],
                         };
                     }
+                    // Work pool handlers (#2083)
+                    case 'list_work_pools': {
+                        const parsed = ListCategoriesSchema.parse(args);
+                        const pools = await this.client.listWorkPools(parsed.project_slug || this.client.getProjectSlug() || undefined);
+                        return { content: [{ type: 'text', text: JSON.stringify(pools, null, 2) }] };
+                    }
+                    case 'add_work_pool_member': {
+                        const parsed = WorkPoolMemberSchema.parse(args);
+                        await this.client.addWorkPoolMember(parsed.work_pool, parsed.user_id, parsed.project_slug || this.client.getProjectSlug() || undefined);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Added ${parsed.user_id} to work pool "${parsed.work_pool}"`,
+                                },
+                            ],
+                        };
+                    }
+                    case 'remove_work_pool_member': {
+                        const parsed = WorkPoolMemberSchema.parse(args);
+                        await this.client.removeWorkPoolMember(parsed.work_pool, parsed.user_id, parsed.project_slug || this.client.getProjectSlug() || undefined);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Removed ${parsed.user_id} from work pool "${parsed.work_pool}"`,
+                                },
+                            ],
+                        };
+                    }
                     // Tag handlers
                     case 'list_tags': {
                         const parsed = ListTagsSchema.parse(args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolfpack-mcp",
-  "version": "1.0.90",
+  "version": "1.0.92",
   "description": "MCP server for Wolfpack AI-enhanced software delivery tools",
   "main": "dist/index.js",
   "type": "module",