wolfpack-mcp 1.0.89 → 1.0.91

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'],
@@ -428,6 +432,12 @@ export const AGENT_BUILDER_TOOLS = [
             properties: {
                 agent_id: { type: 'string', description: 'Agent profile ID' },
                 task_id: { type: 'string', description: 'Task ID to run' },
+                prompt: {
+                    type: 'string',
+                    description: "Extra instructions for this run only, appended to the task's saved prompt. " +
+                        'The task still runs as written — this is added after it, and the task is not changed. ' +
+                        'Omit it to run the task exactly as saved.',
+                },
                 project_slug: { type: 'string', description: 'Project to scope the session to (optional)' },
                 git_ref: {
                     type: 'string',
@@ -526,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' },
@@ -569,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' },
@@ -792,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) {
@@ -849,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);
@@ -872,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)}` }] };
         }
@@ -1110,13 +1170,14 @@ export async function handleAgentBuilderTool(name, args, client) {
                 .object({
                 agent_id: z.string(),
                 task_id: z.string(),
+                prompt: z.string().optional(),
                 project_slug: z.string().optional(),
                 git_ref: z.string().optional(),
                 pr_number: z.number().int().positive().optional(),
                 org_slug: orgSlugField,
             })
                 .parse(args);
-            const result = await client.runAgentTask(parsed.agent_id, parsed.task_id, parsed.project_slug, resolveOrg(parsed), parsed.git_ref, parsed.pr_number);
+            const result = await client.runAgentTask(parsed.agent_id, parsed.task_id, parsed.project_slug, resolveOrg(parsed), parsed.git_ref, parsed.pr_number, parsed.prompt);
             return {
                 content: [
                     {
@@ -1159,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,
             })
@@ -1183,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)}`,
+                    },
                 ],
             };
         }
@@ -1206,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,
             })
@@ -1230,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

@@ -74,3 +74,92 @@ describe('per-task model pin over MCP (#2034)', () => {
         expect(updateAgentTask.mock.calls[0][2]).toEqual({ prompt: 'Analyse the transcript twice.' });
     });
 });
+// #2048 — run_agent_task can add instructions for one run without editing the
+// task. The prompt is the 7th argument of client.runAgentTask, so these assert
+// on the position as well as the value.
+describe('extra instructions on a task run over MCP (#2048)', () => {
+    const runClient = () => {
+        const runAgentTask = vi.fn().mockResolvedValue({ entryId: 'e1', position: 0, executing: true });
+        return { client: { runAgentTask }, runAgentTask };
+    };
+    it('advertises the prompt argument as an addition, not a replacement', () => {
+        const properties = toolNamed('run_agent_task').inputSchema.properties;
+        expect(properties.prompt.description).toContain("appended to the task's saved prompt");
+    });
+    it('sends the extra instructions with the run', async () => {
+        const { client, runAgentTask } = runClient();
+        await handleAgentBuilderTool('run_agent_task', { agent_id: 'agent-1', task_id: 'task-1', prompt: 'Only cover last week.' }, client);
+        expect(runAgentTask.mock.calls[0][1]).toBe('task-1');
+        expect(runAgentTask.mock.calls[0][6]).toBe('Only cover last week.');
+    });
+    it('sends none when the caller only wants the task as saved', async () => {
+        const { client, runAgentTask } = runClient();
+        await handleAgentBuilderTool('run_agent_task', { agent_id: 'agent-1', task_id: 'task-1' }, client);
+        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,6 +247,8 @@ 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));
     }
@@ -502,6 +504,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();
@@ -748,8 +760,9 @@ export class WolfpackClient {
     async updateAgentTask(agentId, taskId, body, orgSlug) {
         return this.api.patch(this.withOrgSlug(`/agents/${agentId}/tasks/${taskId}`, orgSlug), body);
     }
-    async runAgentTask(agentId, taskId, teamSlug, orgSlug, gitRef, prNumber) {
-        return this.api.post(this.withOrgSlug(`/agents/${agentId}/tasks/${taskId}/run`, orgSlug), { teamSlug, gitRef, prNumber });
+    /** `prompt` is appended to the task's saved prompt for this run only (#2048). */
+    async runAgentTask(agentId, taskId, teamSlug, orgSlug, gitRef, prNumber, prompt) {
+        return this.api.post(this.withOrgSlug(`/agents/${agentId}/tasks/${taskId}/run`, orgSlug), { teamSlug, gitRef, prNumber, prompt });
     }
     // ─── Agent Builder: Queue ──────────────────────────────────────────────────
     async listAgentQueue(agentId, status, orgSlug) {

package/dist/index.js

@@ -215,11 +215,20 @@ 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()
@@ -1100,6 +1109,10 @@ 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)',
@@ -1837,6 +1850,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 +2498,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'
@@ -2938,6 +2997,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.89",
+  "version": "1.0.91",
   "description": "MCP server for Wolfpack AI-enhanced software delivery tools",
   "main": "dist/index.js",
   "type": "module",