wolfpack-mcp 1.0.113 → 1.0.115

package/dist/agentBuilderTools.js

@@ -160,12 +160,12 @@ export const AGENT_BUILDER_TOOLS = [
                 },
                 config: {
                     type: 'object',
-                    description: 'The agent\'s own Ghost runtime settings, merged into every session\'s generated config. Two keys are honoured: "options" (e.g. {"max_turn_requests": 150} — the per-turn model request cap, default 200) and "agents" (per-agent overrides, e.g. {"coder": {"disabled_tools": ["agent"]}} to switch the sub-agent tool off). Other keys are ignored. Replaces the stored config as a whole; set to null to clear. Ghost runtime only — Claude Code agents ignore it.',
+                    description: 'The agent\'s own Raiven (formerly Ghost) runtime settings, merged into every session\'s generated config. Two keys are honoured: "options" (e.g. {"max_turn_requests": 150} — the per-turn model request cap, default 200) and "agents" (per-agent overrides, e.g. {"coder": {"disabled_tools": ["agent"]}} to switch the sub-agent tool off). Other keys are ignored. Replaces the stored config as a whole; set to null to clear. Raiven runtime only — Claude Code agents ignore it.',
                 },
                 disabled_tools: {
                     type: 'array',
                     items: { type: 'string' },
-                    description: 'Tools the agent never gets, whatever starts the session (a task, a chat, a work-item pickup). Ghost names ("agent", "fetch"); Claude Code agents use Claude Code\'s own ("Task", "WebFetch") and "mcp__<server>__<tool>" for an MCP tool. Replaces the stored list; an empty array clears it. A task\'s own disabled_tools are added to these — a task narrows further, never widens.',
+                    description: 'Tools the agent never gets, whatever starts the session (a task, a chat, a work-item pickup). Raiven (formerly Ghost) tool names ("agent", "fetch"); Claude Code agents use Claude Code\'s own ("Task", "WebFetch") and "mcp__<server>__<tool>" for an MCP tool. Replaces the stored list; an empty array clears it. A task\'s own disabled_tools are added to these — a task narrows further, never widens.',
                 },
                 disabled_mcp_servers: {
                     type: 'array',

package/dist/index.js

@@ -8,11 +8,11 @@ import { readFile, stat } from 'fs/promises';
 import { basename, extname, resolve } from 'path';
 import { WolfpackClient } from './client.js';
 import { productName } from './brand.js';
-import { allTasksChecked, getWorkItemReminders } from './workItemReminders.js';
+import { allTasksChecked, getProgressReminder, getWorkItemReminders } from './workItemReminders.js';
 import { validateConfig, config } from './config.js';
 import { handleAgentBuilderTool } from './agentBuilderTools.js';
 import { handleProcedureTool } from './procedureTools.js';
-import { stdioTools, toolNamesFor, withProductName } from './toolCatalogue.js';
+import { stdioTools, toolNamesFor, undeclaredArgumentsError, withProductName, } from './toolCatalogue.js';
 import { handleAgentSelfTool } from './agentSelfTools.js';
 import { handleAgentObserveTool } from './agentObserveTools.js';
 import { handleBrowserTool } from './browserTools.js';
@@ -118,6 +118,8 @@ const UpdateWorkProgressSchema = z.object({
         .optional()
         .describe('Project slug (required for multi-project users, use list_projects to get slugs)'),
 });
+/** The risk vocabulary, as the backend's `VALID_RISKS` holds it. */
+const VALID_RISKS = ['High', 'Medium', 'Low'];
 const VALID_STATUSES = [
     'pending',
     'new',
@@ -159,6 +161,11 @@ const UpdateWorkItemSchema = z.object({
         .nullable()
         .optional()
         .describe('Size estimate: "S" (small), "M" (medium), "L" (large), or null to remove'),
+    risk: z
+        .enum(VALID_RISKS)
+        .nullable()
+        .optional()
+        .describe('Risk assessment: "High", "Medium", "Low", or null to clear it'),
     assisting_user1_id: z
         .string()
         .nullable()
@@ -383,6 +390,7 @@ const CreateWorkItemSchema = z.object({
         .enum(['S', 'M', 'L'])
         .optional()
         .describe('Size estimate: "S" (small), "M" (medium), "L" (large)'),
+    risk: z.enum(VALID_RISKS).optional().describe('Risk assessment: "High", "Medium" or "Low"'),
     leading_user_id: z
         .string()
         .optional()
@@ -877,6 +885,11 @@ class WolfpackMCPServer {
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
             try {
+                // A parameter no case below reads is dropped in silence, and the call answers as
+                // a success the caller cannot tell from one that applied it (#2633).
+                const undeclared = undeclaredArgumentsError(name, args);
+                if (undeclared)
+                    throw new Error(undeclared);
                 switch (name) {
                     // Project handlers
                     case 'list_projects': {
@@ -970,22 +983,18 @@ class WolfpackMCPServer {
                     case 'update_work_progress': {
                         const parsed = UpdateWorkProgressSchema.parse(args);
                         const teamSlug = parsed.project_slug || this.client.getProjectSlug() || undefined;
-                        let workItem = await this.client.updateWorkProgress(parsed.work_item_id, parsed.description, teamSlug);
+                        const workItem = await this.client.updateWorkProgress(parsed.work_item_id, parsed.description, teamSlug);
                         if (workItem) {
-                            let summary = `Updated description on: ${workItem.title}`;
-                            // Recording progress means the work is under way: a "new" item starts, and an
-                            // item in "review" comes back to "doing" because its developer is working on it
-                            // again (#1787) — otherwise the board keeps showing handed-over work that is
-                            // still being changed.
-                            const previousStatus = workItem.status;
-                            if (previousStatus === 'new' || previousStatus === 'review') {
-                                const advanced = await this.moveToDoing(parsed.work_item_id, teamSlug);
-                                if (advanced) {
-                                    workItem = advanced;
-                                    summary += ` (status auto-advanced ${previousStatus} → doing)`;
-                                }
-                            }
+                            // Writing a description is not a claim that work has started: it is also how a
+                            // plan is added before pickup and how the record is tidied after handover, so
+                            // this tool no longer moves the item (#2634). The status it left is named
+                            // outright, and getProgressReminder says what to call to move it.
+                            const summary = `Updated description on: ${workItem.title} (status unchanged: ${workItem.status})`;
                             let text = `${summary}\n\n${JSON.stringify(stripUuids(workItem), null, 2)}`;
+                            const reminder = getProgressReminder(workItem.status);
+                            if (reminder) {
+                                text = `${reminder}\n\n${text}`;
+                            }
                             if (workItem.status === 'doing' && allTasksChecked(workItem.description)) {
                                 text =
                                     'REMINDER: All plan tasks are checked off. If the work is complete, set status to "review" NOW (update_work_item) and add a completion comment.\n\n' +
@@ -1023,6 +1032,8 @@ class WolfpackMCPServer {
                             fields.priority = parsed.priority;
                         if (parsed.size !== undefined)
                             fields.size = parsed.size;
+                        if (parsed.risk !== undefined)
+                            fields.risk = parsed.risk;
                         if (parsed.assisting_user1_id !== undefined)
                             fields.assistingUser1Id = parsed.assisting_user1_id;
                         if (parsed.assisting_user2_id !== undefined)
@@ -1067,6 +1078,8 @@ class WolfpackMCPServer {
                             }
                             if (parsed.size !== undefined)
                                 changes.push(parsed.size ? `size → ${parsed.size}` : 'size removed');
+                            if (parsed.risk !== undefined)
+                                changes.push(parsed.risk ? `risk → ${parsed.risk}` : 'risk cleared');
                             if (parsed.assisting_user1_id !== undefined)
                                 changes.push(parsed.assisting_user1_id
                                     ? `assisting user 1 updated`
@@ -1347,6 +1360,7 @@ class WolfpackMCPServer {
                             status: parsed.status,
                             priority: parsed.priority,
                             size: parsed.size,
+                            risk: parsed.risk,
                             leadingUserId: parsed.leading_user_id,
                             categoryId: parsed.category_id,
                             radarItemId,
@@ -2079,24 +2093,6 @@ class WolfpackMCPServer {
             }
         });
     }
-    /**
-     * Put a work item in "doing" after progress was recorded on it, and report whether that
-     * stuck. An agent whose work pool may not set "doing" — a reviewer annotating an item in
-     * "review" rather than the developer resuming it — is refused by the backend status
-     * policy; that refusal is the right answer, so it leaves the saved note alone instead of
-     * failing the call the agent actually made.
-     */
-    async moveToDoing(workItemId, teamSlug) {
-        try {
-            return await this.client.updateWorkItem(workItemId, { status: 'doing' }, teamSlug);
-        }
-        catch (error) {
-            if (error && typeof error === 'object' && 'status' in error && error.status === 403) {
-                return null;
-            }
-            throw error;
-        }
-    }
     isImageBuffer(buffer) {
         if (buffer.length < 4)
             return false;

package/dist/stdioToolPermissions.test.js

@@ -32,7 +32,8 @@ const stubBackend = async (body) => {
     await new Promise((resolve) => backend.listen(0, '127.0.0.1', resolve));
     return `http://127.0.0.1:${backend.address().port}/api/mcp`;
 };
-const toolNamesFrom = async (apiUrl) => {
+/** Runs `use` against the real server, spawned and connected the way a client does. */
+const withClient = async (apiUrl, use) => {
     const client = new Client({ name: 'test', version: '1.0.0' });
     const transport = new StdioClientTransport({
         // tsx directly, not via npx: the transport kills the process it spawned,
@@ -50,12 +51,15 @@ const toolNamesFrom = async (apiUrl) => {
     });
     await client.connect(transport);
     try {
-        return (await client.listTools()).tools.map((t) => t.name);
+        return await use(client);
     }
     finally {
         await client.close();
     }
 };
+const toolNamesFrom = async (apiUrl) => withClient(apiUrl, async (client) => (await client.listTools()).tools.map((t) => t.name));
+/** What a tool call answers with, as text — the error text included. */
+const callToolOver = async (apiUrl, name, args) => withClient(apiUrl, async (client) => JSON.stringify(await client.callTool({ name, arguments: args })));
 afterEach(async () => {
     await new Promise((resolve) => backend?.close(() => resolve()) ?? resolve());
     backend = undefined;
@@ -100,3 +104,29 @@ describe('the tool list served over stdio', () => {
         expect(names).toContain('update_work_item');
     }, 60_000);
 });
+/**
+ * #2633 — the server builds each request by copying a fixed list of keys out of the
+ * arguments, so a parameter no case reads was dropped without a word and the call
+ * answered as a success. That is how `risk` went missing: the catalogue never declared
+ * it, so no case read it, so every attempt to set one quietly did nothing.
+ */
+describe('an argument over stdio', () => {
+    const key = async () => stubBackend({ capabilities: ['project'], permissions: ['mcp:work_items:update'] });
+    it('is refused naming the field when the tool does not declare it (#2633)', async () => {
+        const answer = await callToolOver(await key(), 'update_work_item', {
+            work_item_id: '1',
+            rsik: 'High',
+        });
+        expect(answer).toContain('rsik');
+        expect(answer).toContain('has no parameter');
+    }, 60_000);
+    // The other half: the guard must not swallow the parameter the item added. The stub
+    // answers no route but a 503, so getting that far is the proof it was forwarded.
+    it('reaches the backend when the tool does declare it (#2633)', async () => {
+        const answer = await callToolOver(await key(), 'update_work_item', {
+            work_item_id: '1',
+            risk: 'High',
+        });
+        expect(answer).not.toContain('has no parameter');
+    }, 60_000);
+});

package/dist/toolCatalogue.js

@@ -50,6 +50,14 @@ const CONTENT_LINKING_HELP = 'CROSS-REFERENCES: In any markdown content, you can
     '#j123 or #journal-123 for journal entries, #c123 or #case-123 for cases, #p123 or #proc-123 for procedures. ' +
     'Use @username to mention team members (triggers notifications). ' +
     'Standard markdown links also work: [link text](/project/{slug}/work-items/123).';
+/**
+ * The risk vocabulary, said the same way on every tool that carries it (#2633).
+ *
+ * The field existed on the model and in the UI from #2504 and on no write tool, so an
+ * agent that assessed risk while planning could only write it into the description.
+ */
+const RISK_DESCRIPTION = 'Risk assessment: "High", "Medium" or "Low" — the exact words, capitalised. ' +
+    'An item nobody has assessed has none, which is not the same as "Low".';
 const FORM_FIELD_ITEM_SCHEMA = {
     type: 'object',
     properties: {
@@ -195,6 +203,17 @@ const SHARED_TOOLS = [
                     description: 'Filter by linked radar/initiative item. Accepts refId (e.g. "5" or "#r5"), UUID, ' +
                         'or one of "none" (no link), "any" (has any link), "all" (no filter).',
                 },
+                // Accepted by the stdio schema and by the controller since they were added, and
+                // declared on neither transport until #2633 — so undiscoverable to a client
+                // reading the tool list, and dropped outright by the remote server.
+                created_by_id: {
+                    type: 'string',
+                    description: 'Filter by creator user ID',
+                },
+                updated_by_id: {
+                    type: 'string',
+                    description: 'Filter by last updater user ID',
+                },
                 sort_by: {
                     type: 'string',
                     description: 'Sort field: "dateUpdated" (default, newest activity first), "dateCreated", "priority", "title"',
@@ -239,6 +258,7 @@ const SHARED_TOOLS = [
             'REVIEW CHECKS: items under review may carry review checks (code-review, security-review, ...); see list_work_item_checks and claim/complete_work_item_check. ' +
             'DEPENDENCIES: dependsOn lists the work this item follows and nextItems the work that follows it, each with satisfied=true once it has finished. ' +
             'An item with an unsatisfied entry in dependsOn cannot be pulled yet — take the work it depends on first. ' +
+            `RISK: ${RISK_DESCRIPTION} Set it with update_work_item rather than writing the assessment into the description. ` +
             'IMAGES: Image references in the description (e.g. `![alt](/api/files/...)`) can be viewed using the download_image tool.',
         inputSchema: {
             type: 'object',
@@ -259,7 +279,7 @@ const SHARED_TOOLS = [
         name: 'update_work_progress',
         permission: 'mcp:work_items:update',
         description: 'Update work item description/notes with your progress. WORKFLOW: 1) get_work_item to read current notes 2) Modify the markdown description with new findings/progress 3) Call this with the complete updated description. The full description replaces the existing one. ' +
-            'STATUS: Items in "new" — and items in "review" you are picking back up — are auto-advanced to "doing" (recording progress means work is under way). Completing the work is NOT auto-detected: when done, set status to "review" via update_work_item and add a completion comment. ' +
+            'STATUS: This tool never changes status — editing the description is also how a plan is added before pickup and how the record is tidied after handover (#2634). The response names the status it left the item in. Moving an item is always your own call: pull_work_item to start it, update_work_item to set "doing" when you pick it back up, and "review" with a completion comment when it is done. ' +
             'CRITICAL: NEVER overwrite or remove the original description text. Preserve all existing content exactly as-is. Append your plan below a "---" separator. You may only modify content you previously added (your plan section). ' +
             'BEST PRACTICE: Append a plan with markdown checkboxes (- [ ] task). Check off completed tasks (- [x] task) as you progress. Include sections for: Plan (checklist), Approach (strategy), and Notes (discoveries/decisions). ' +
             CONTENT_LINKING_HELP,
@@ -284,7 +304,8 @@ const SHARED_TOOLS = [
         permission: 'mcp:work_items:update',
         description: 'Update one or more fields on a work item. Only provide the fields you want to change. ' +
             'Supports: title, description, status, leading_user_id (assignee), assisting_user1/2/3_id, ' +
-            'radar_item_id (initiative), category_id, priority (0-4), size (S/M/L), work_pool_id, tags, and closing_comment. ' +
+            'radar_item_id (initiative), category_id, priority (0-4), size (S/M/L), risk (High/Medium/Low), ' +
+            'work_pool_id, tags, and closing_comment. ' +
             'STATUS WORKFLOW: "pending" (backlog) → "new" (to do) → "doing" (in progress) → "review" (work done) → "ready" (awaiting deployment) → "completed" (deployed). ' +
             'Use "blocked" when work cannot proceed. AGENTS: you cannot start un-started work here — ' +
             'a status change on a "pending" or "new" item that is not assigned to you is refused. ' +
@@ -348,6 +369,11 @@ const SHARED_TOOLS = [
                     enum: ['S', 'M', 'L', null],
                     description: 'Size estimate: "S" (small), "M" (medium), "L" (large), or null to remove',
                 },
+                risk: {
+                    type: ['string', 'null'],
+                    enum: ['High', 'Medium', 'Low', null],
+                    description: `${RISK_DESCRIPTION} Use null to clear it.`,
+                },
                 assisting_user1_id: {
                     type: ['string', 'null'],
                     description: 'User ID for first assisting user, or null to remove',
@@ -851,6 +877,11 @@ const SHARED_TOOLS = [
                     enum: ['S', 'M', 'L'],
                     description: 'Size estimate: "S" (small), "M" (medium), "L" (large)',
                 },
+                risk: {
+                    type: 'string',
+                    enum: ['High', 'Medium', 'Low'],
+                    description: RISK_DESCRIPTION,
+                },
                 leading_user_id: {
                     type: 'string',
                     description: 'User ID to assign as leading user. AGENTS: you may put your own id here — filing work you already know you will do is the one assignment that is yours to make. Leaving it out is just as normal: the Delivery Lead assigns it instead. Either way the item waits in the backlog for a human to approve before you can pull it.',
@@ -2313,6 +2344,30 @@ export function stdioTools(capabilities, permissions) {
     return TOOL_CATALOGUE.filter((t) => (!t.capability || capabilities.includes(t.capability)) &&
         (!t.permission || !permissions || holdsScope(permissions, t.permission))).map(toTool);
 }
+/**
+ * The complaint about arguments the tool does not declare, or null when there are none.
+ *
+ * Both servers build a tool's request by copying a fixed list of keys out of the
+ * arguments, so anything else was dropped without a word and the call answered as a
+ * success — `risk` on `update_work_item` was set by hand in the UI for weeks because of
+ * it (#2633). A silently ignored parameter is the worst failure mode available: the
+ * caller cannot tell it from one that was applied.
+ *
+ * The backend's remote server holds its own copy of this, against the generated
+ * catalogue; keep the two saying the same thing.
+ */
+export function undeclaredArgumentsError(name, args) {
+    const tool = TOOL_CATALOGUE.find((t) => t.name === name);
+    // A name no tool answers to is the dispatch's own complaint to make, not ours.
+    if (!tool)
+        return null;
+    const declared = Object.keys(tool.inputSchema?.properties ?? {});
+    const undeclared = Object.keys(args ?? {}).filter((key) => !declared.includes(key));
+    if (undeclared.length === 0)
+        return null;
+    return (`${name} has no parameter ${undeclared.map((k) => `"${k}"`).join(', ')}. ` +
+        `It accepts: ${declared.join(', ')}.`);
+}
 /** The names a capability gates, for routing a call to that family's handler. */
 export function toolNamesFor(capability) {
     return TOOL_CATALOGUE.filter((t) => t.capability === capability).map((t) => t.name);

package/dist/toolCatalogue.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { readFileSync } from 'fs';
 import { join } from 'path';
 import * as catalogue from './toolCatalogue.js';
-import { TOOL_CATALOGUE, remoteTools, toolPermissions, stdioTools, toolNamesFor, } from './toolCatalogue.js';
+import { TOOL_CATALOGUE, remoteTools, toolPermissions, stdioTools, toolNamesFor, undeclaredArgumentsError, } from './toolCatalogue.js';
 import { BROWSER_TOOLS } from './browserTools.js';
 import { AGENT_SELF_TOOLS, AGENT_MEMORY_TOOLS } from './agentSelfTools.js';
 import { AGENT_OBSERVE_TOOLS } from './agentObserveTools.js';
@@ -132,6 +132,32 @@ describe('the MCP tool catalogue', () => {
         expect(stdioTools(['project']).map((t) => t.name)).toEqual(stdioTools(['project'], null).map((t) => t.name));
         expect(stdioTools(['project'], null).map((t) => t.name)).toContain('update_work_item');
     });
+    it('declares the risk on both tools that write a work item (#2633)', () => {
+        // The column, the pill and the vocabulary all shipped with #2504 and no write tool
+        // carried the field, so an agent could read an assessment and never record one.
+        const risk = (name) => TOOL_CATALOGUE.find((t) => t.name === name).inputSchema.properties.risk;
+        expect(risk('create_work_item').enum).toEqual(['High', 'Medium', 'Low']);
+        // Nullable on the update alone: clearing an assessment is a thing to do to an item
+        // that has one, and "not assessed" is not a value you create an item with.
+        expect(risk('update_work_item').enum).toEqual(['High', 'Medium', 'Low', null]);
+        // And the read says what the words mean, so a caller need not guess the casing.
+        const read = TOOL_CATALOGUE.find((t) => t.name === 'get_work_item');
+        expect(read.description).toContain('"High", "Medium" or "Low"');
+    });
+    it('complains about an argument the tool does not declare (#2633)', () => {
+        expect(undeclaredArgumentsError('update_work_item', { work_item_id: '1', risk: 'High' })).toBeNull();
+        expect(undeclaredArgumentsError('update_work_item', undefined)).toBeNull();
+        expect(undeclaredArgumentsError('update_work_item', { work_item_id: '1', rsik: 'High' })).toContain('update_work_item has no parameter "rsik". It accepts: work_item_id, title,');
+        // A name no tool answers to is the dispatch's own complaint, not this one's.
+        expect(undeclaredArgumentsError('no_such_tool', { anything: 1 })).toBeNull();
+    });
+    it('guards the remote dispatch in the same words (#2633)', () => {
+        // The catalogue crosses the package boundary as data, so the remote server holds
+        // its own copy of the check. Two copies may not say two different things.
+        const server = repoFile('packages/backend/src/mcp/server.ts');
+        expect(server).toContain('has no parameter');
+        expect(server).toContain('It accepts: ');
+    });
     it('takes the remote override only where one is set', () => {
         // upload_image is the single tool whose two clients cannot share a contract.
         const overridden = TOOL_CATALOGUE.filter((t) => t.remote).map((t) => t.name);

package/dist/updateWorkProgress.test.js

@@ -0,0 +1,123 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { createServer } from 'http';
+import { fileURLToPath } from 'url';
+/**
+ * #2634 — what `update_work_progress` actually sends.
+ *
+ * The defect was a second request nobody asked for: after writing the description the
+ * server fired `PATCH /work-items/{id} {status:'doing'}` whenever the item sat in "new"
+ * or "review", so a planning edit started unstarted work and a bookkeeping tick pulled
+ * handed-over work back off the review queue. Asserting on the response text alone would
+ * not have caught it — the write is the defect — so this drives the real server over a
+ * stdio transport and records every request the stub backend receives.
+ */
+const entryPoint = fileURLToPath(new URL('./index.ts', import.meta.url));
+let backend;
+/** Every request the server made, as "METHOD /path" with the query string dropped. */
+let requests = [];
+/**
+ * A backend that answers the progress write with an item in `status`, and would answer a
+ * status PATCH too — the test has to fail on the recorded request, not on an error the
+ * call happened to raise.
+ */
+const stubBackend = async (status) => {
+    const workItem = (itemStatus) => ({
+        id: 'aa3d9bd0-7f3a-4d2f-8a26-61b1b0b0f001',
+        refId: 42,
+        title: 'Risk assessment wanted',
+        description: 'Original text\n\n---\n\n- [ ] first task',
+        status: itemStatus,
+    });
+    backend = createServer((req, res) => {
+        const path = (req.url ?? '').split('?')[0];
+        requests.push(`${req.method} ${path}`);
+        const json = (body) => {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(body));
+        };
+        if (path.endsWith('/capabilities')) {
+            return json({ capabilities: ['project'], permissions: ['mcp:work_items:update'] });
+        }
+        if (path.endsWith('/teams')) {
+            return json({ teams: [] });
+        }
+        if (req.method === 'PUT' && path.endsWith('/progress')) {
+            return json(workItem(status));
+        }
+        if (req.method === 'PATCH' && path.includes('/work-items/')) {
+            return json(workItem('doing'));
+        }
+        res.writeHead(503).end();
+    });
+    await new Promise((resolve) => backend.listen(0, '127.0.0.1', resolve));
+    return `http://127.0.0.1:${backend.address().port}/api/mcp`;
+};
+/** The text `update_work_progress` answers with, driven the way a client drives it. */
+const recordProgress = async (apiUrl) => {
+    const client = new Client({ name: 'test', version: '1.0.0' });
+    const transport = new StdioClientTransport({
+        // tsx directly, not via npx: the transport kills the process it spawned, and an npx
+        // wrapper would leave the server orphaned behind it.
+        command: process.execPath,
+        args: ['--import', 'tsx', entryPoint],
+        env: {
+            ...process.env,
+            WOLFPACK_API_KEY: 'wfp_sk_test',
+            WOLFPACK_API_URL: apiUrl,
+            WOLFPACK_PROJECT_SLUG: '',
+            WOLFPACK_TEAM_SLUG: '',
+            WOLFPACK_ORG_SLUG: '',
+        },
+    });
+    await client.connect(transport);
+    try {
+        const result = (await client.callTool({
+            name: 'update_work_progress',
+            arguments: {
+                work_item_id: '42',
+                description: 'Original text\n\n---\n\n- [ ] first task',
+            },
+        }));
+        return result.content.map((c) => c.text).join('\n');
+    }
+    finally {
+        await client.close();
+    }
+};
+afterEach(async () => {
+    await new Promise((resolve) => backend?.close(() => resolve()) ?? resolve());
+    backend = undefined;
+    requests = [];
+});
+describe('update_work_progress over stdio', () => {
+    it('writes the description of an item in "new" and nothing else (#2629)', async () => {
+        const text = await recordProgress(await stubBackend('new'));
+        expect(requests).toContain('PUT /api/mcp/work-items/42/progress');
+        expect(requests.filter((r) => r.startsWith('PATCH'))).toEqual([]);
+        expect(text).not.toContain('auto-advanced');
+        expect(text).toContain('(status unchanged: new)');
+        expect(text).toContain('"status": "new"');
+    }, 60_000);
+    it('leaves an item in "review" on the review queue (#2628)', async () => {
+        const text = await recordProgress(await stubBackend('review'));
+        expect(requests.filter((r) => r.startsWith('PATCH'))).toEqual([]);
+        expect(text).toContain('(status unchanged: review)');
+        expect(text).toContain('"status": "review"');
+    }, 60_000);
+    it('tells a caller who IS picking the item up what to call', async () => {
+        // The convenience is not simply removed: the response says what the tool no longer
+        // does for you, so resuming work still puts the item in "doing" — by the caller's own
+        // update_work_item, which is the only thing that should move it (#1787 kept honest).
+        const text = await recordProgress(await stubBackend('review'));
+        expect(text).toContain('set status to "doing" (update_work_item)');
+    }, 60_000);
+    it('still reports the status of an item already under way', async () => {
+        const text = await recordProgress(await stubBackend('doing'));
+        expect(requests.filter((r) => r.startsWith('PATCH'))).toEqual([]);
+        expect(text).toContain('(status unchanged: doing)');
+        // Nothing to pick up, so no pick-it-up reminder
+        expect(text).not.toContain('BEFORE starting');
+    }, 60_000);
+});

package/dist/workItemReminders.js

@@ -29,6 +29,18 @@ const STATUS_REMINDERS = {
         'up (rework, review feedback, a follow-up change), set status to "doing" (update_work_item) BEFORE ' +
         'starting, so the board shows the work is under way again. If you are reviewing it, leave it where it is.',
 };
+/**
+ * The reminder an `update_work_progress` response carries, or null when there is nothing to
+ * act on. Recording progress used to move the item itself (#2634): a planning edit started
+ * work nobody had started, and a bookkeeping tick pulled handed-over work back out of
+ * "review". Only the caller knows which it is, so the two statuses that used to be moved for
+ * them are the two that now get told what to call — the same words get_work_item uses.
+ */
+export function getProgressReminder(status) {
+    if (status !== 'new' && status !== 'review')
+        return null;
+    return STATUS_REMINDERS[status];
+}
 // Reminders to prepend to a get_work_item response, most urgent first.
 export function getWorkItemReminders(status, description, approved, question) {
     const reminders = [];

package/dist/workItemReminders.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { hasPlan, allTasksChecked, getWorkItemReminders } from './workItemReminders.js';
+import { hasPlan, allTasksChecked, getProgressReminder, getWorkItemReminders, } from './workItemReminders.js';
 const PLAN = 'Original text\n\n---\n\n## Plan\n\n- [x] first task\n- [ ] second task';
 const DONE_PLAN = 'Original text\n\n---\n\n## Plan\n\n- [x] first task\n- [x] second task';
 describe('hasPlan', () => {
@@ -76,3 +76,20 @@ describe('getWorkItemReminders', () => {
         expect(getWorkItemReminders('ready', PLAN)).toEqual([]);
     });
 });
+describe('getProgressReminder', () => {
+    // #2634 — these two statuses are exactly the ones a description edit used to move for the
+    // caller. The reminder replaces the write, so it has to fire on both and say what to call.
+    it('tells a caller picking up a "new" item to set "doing" first', () => {
+        expect(getProgressReminder('new')).toContain('set status to "doing" (update_work_item)');
+    });
+    it('tells a caller reworking a handed-over item to set "doing", and a reviewer to leave it', () => {
+        const reminder = getProgressReminder('review');
+        expect(reminder).toContain('set status to "doing" (update_work_item)');
+        expect(reminder).toContain('If you are reviewing it, leave it where it is');
+    });
+    // Work already under way needs no nudge, and a finished item must not be invited back:
+    // suggesting "doing" on "ready" or "completed" would re-open the #2628 occurrence in words.
+    it.each(['pending', 'doing', 'paused', 'blocked', 'ready', 'completed', 'closed'])('stays quiet on %s', (status) => {
+        expect(getProgressReminder(status)).toBeNull();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolfpack-mcp",
-  "version": "1.0.113",
+  "version": "1.0.115",
   "description": "MCP server for Clachan (formerly Wolfpack), AI-enhanced software delivery tools",
   "main": "dist/index.js",
   "type": "module",