wolfpack-mcp 1.0.103 → 1.0.105

package/README.md

@@ -309,6 +309,49 @@ Update an existing journal entry.
 - `entry_id` (required): The entry UUID
 - `title`, `content` (optional)
 
+### Ideas (the Idea Factory)
+
+Offered to a key holding `mcp:ideas:read` on a project where the `idea-factory` feature is
+switched on. There is no archive tool: archiving is the Idea Factory's delete, and MCP does not
+surface deletes.
+
+#### `list_ideas`
+
+List the live ideas in a project. Each carries a stage and a boost count, and the response says
+whether your own boost for today in that project is already spent.
+
+- `sort` (optional): `popular` (default), `updated` or `newest`
+- `limit`, `offset` (optional): Pagination
+
+#### `get_idea`
+
+Get a single idea, with its tags and the reference numbers of any work items being built from it.
+
+- `idea_id` (required): The idea refId (number)
+
+#### `create_idea`
+
+Raise a new idea. It starts at the `spark` stage with no boosts.
+
+- `title` (required): Idea title
+- `content` (required): Markdown content
+
+#### `update_idea`
+
+Update an idea, or move it to another stage.
+
+- `idea_id` (required): The idea refId (number)
+- `title`, `content` (optional)
+- `stage` (optional): `spark`, `exploring`, `building`, `shipped` or `parked`
+
+#### `boost_idea`
+
+Vote for an idea by spending your boost. One boost per project per day, whichever idea you spend
+it on — spending it again the same day is refused rather than counted. Takes `mcp:ideas:boost`,
+which is separate from `mcp:ideas:update`: voting is participation, not editing.
+
+- `idea_id` (required): The idea refId (number)
+
 ### Comments
 
 #### `list_work_item_comments`

package/dist/brand.js

@@ -0,0 +1,13 @@
+/**
+ * What the product calls itself, and the domain it is served from (#2466).
+ *
+ * This package is published and installed on its own, away from the repository, so —
+ * unlike the Vite apps — it cannot read `brand.json`. It takes the values from the
+ * environment, with the fallbacks below pinned to `brand.json` by
+ * `scripts/check-product-brand.js`.
+ *
+ * `WOLFPACK_*` variables are this package's public configuration contract with the MCP
+ * clients that already set them, so they are deliberately not renamed here.
+ */
+export const productName = process.env.PRODUCT_NAME || 'Wolfpack';
+export const productDomain = process.env.PRODUCT_DOMAIN || 'wolfpacks.work';

package/dist/client.js

@@ -489,6 +489,33 @@ export class WolfpackClient {
     async updateJournalEntry(entryId, data, teamSlug) {
         return this.api.patch(this.withTeamSlug(`/journal-entries/${encodeURIComponent(entryId)}`, teamSlug), data);
     }
+    // Idea methods (the Idea Factory)
+    async listIdeas(options) {
+        const params = new URLSearchParams();
+        if (options?.teamSlug)
+            params.append('teamSlug', options.teamSlug);
+        if (options?.sort)
+            params.append('sort', options.sort);
+        if (options?.limit !== undefined)
+            params.append('limit', options.limit.toString());
+        if (options?.offset !== undefined)
+            params.append('offset', options.offset.toString());
+        const query = params.toString();
+        return this.api.get(`/ideas${query ? `?${query}` : ''}`);
+    }
+    async getIdea(ideaId, teamSlug) {
+        return this.api.get(this.withTeamSlug(`/ideas/${encodeURIComponent(ideaId)}`, teamSlug));
+    }
+    async createIdea(data) {
+        const { teamSlug, ...rest } = data;
+        return this.api.post('/ideas', { ...rest, teamSlug });
+    }
+    async updateIdea(ideaId, data, teamSlug) {
+        return this.api.put(this.withTeamSlug(`/ideas/${encodeURIComponent(ideaId)}`, teamSlug), data);
+    }
+    async boostIdea(ideaId, teamSlug) {
+        return this.api.post(this.withTeamSlug(`/ideas/${encodeURIComponent(ideaId)}/boost`, teamSlug), {});
+    }
     // Comment methods
     async listWorkItemComments(workItemId, teamSlug) {
         return this.api.get(this.withTeamSlug(`/work-items/${workItemId}/comments`, teamSlug));

package/dist/config.js

@@ -1,5 +1,6 @@
+import { productDomain, productName } from './brand.js';
 export const config = {
-    apiUrl: process.env.WOLFPACK_API_URL || 'https://wolfpacks.work/api/mcp',
+    apiUrl: process.env.WOLFPACK_API_URL || `https://${productDomain}/api/mcp`,
     apiKey: process.env.WOLFPACK_API_KEY,
     projectSlug: process.env.WOLFPACK_PROJECT_SLUG || process.env.WOLFPACK_TEAM_SLUG,
     orgSlug: process.env.WOLFPACK_ORG_SLUG,
@@ -8,7 +9,7 @@ export const config = {
 export function validateConfig() {
     if (!config.apiKey) {
         console.error('Error: WOLFPACK_API_KEY environment variable is required');
-        console.error('Please set WOLFPACK_API_KEY to your API key from the Wolfpack application');
+        console.error(`Please set WOLFPACK_API_KEY to your API key from the ${productName} application`);
         console.error('Example: WOLFPACK_API_KEY=wfp_sk_... (user) or wfp_ak_... (agent)');
         process.exit(1);
     }

package/dist/index.js

@@ -7,11 +7,12 @@ import { createRequire } from 'module';
 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 { validateConfig, config } from './config.js';
 import { AGENT_BUILDER_TOOLS, handleAgentBuilderTool } from './agentBuilderTools.js';
 import { handleProcedureTool } from './procedureTools.js';
-import { stdioTools, toolNamesFor } from './toolCatalogue.js';
+import { stdioTools, toolNamesFor, withProductName } from './toolCatalogue.js';
 import { AGENT_SELF_TOOLS, AGENT_MEMORY_TOOLS, handleAgentSelfTool } from './agentSelfTools.js';
 import { AGENT_OBSERVE_TOOLS, handleAgentObserveTool } from './agentObserveTools.js';
 import { BROWSER_TOOLS, handleBrowserTool } from './browserTools.js';
@@ -65,7 +66,7 @@ const ListWorkItemsSchema = z.object({
     status: z.coerce
         .string()
         .optional()
-        .describe('Filter by status. Board columns: "new", "doing", "review", "ready", "blocked", "completed". Use "pending" or "backlog" for backlog items. Use "all" to include completed/closed. Default excludes completed/closed.'),
+        .describe('Filter by status. Board columns: "new", "doing", "paused", "blocked", "review", "ready", "completed". Use "pending" or "backlog" for backlog items. Use "all" to include completed/closed. Default excludes completed/closed.'),
     assigned_to_id: z.coerce
         .string()
         .optional()
@@ -121,6 +122,7 @@ const VALID_STATUSES = [
     'pending',
     'new',
     'doing',
+    'paused',
     'blocked',
     'review',
     'ready',
@@ -375,7 +377,7 @@ const CreateWorkItemSchema = z.object({
     status: z
         .enum(VALID_STATUSES)
         .optional()
-        .describe('Initial status: "pending" (backlog), "new" (to do), "doing", "review", "ready", "blocked", "completed". Defaults to "new".'),
+        .describe('Initial status: "pending" (backlog), "new" (to do), "doing", "paused", "blocked", "review", "ready", "completed". Defaults to "new".'),
     priority: z.number().optional().describe('Priority level (0-4, higher is more important)'),
     size: z
         .enum(['S', 'M', 'L'])
@@ -532,6 +534,37 @@ const UpdateJournalEntrySchema = z.object({
         .optional()
         .describe('Project slug (required for multi-project users, use list_projects to get slugs)'),
 });
+// Idea schemas (the Idea Factory)
+const PROJECT_SLUG_DESCRIPTION = 'Project slug (required for multi-project users, use list_projects to get slugs)';
+const ListIdeasSchema = z.object({
+    sort: z
+        .string()
+        .optional()
+        .describe('Ordering: "popular" (default, most boosted first), "updated", or "newest"'),
+    limit: z.number().optional().describe('Maximum number of ideas to return'),
+    offset: z.number().optional().describe('Number of ideas to skip'),
+    project_slug: z.string().optional().describe(PROJECT_SLUG_DESCRIPTION),
+});
+const GetIdeaSchema = z.object({
+    idea_id: refIdString().describe('The idea refId (number)'),
+    project_slug: z.string().optional().describe(PROJECT_SLUG_DESCRIPTION),
+});
+const CreateIdeaSchema = z.object({
+    title: z.string().describe('Idea title'),
+    content: z.string().describe('Idea content (markdown)'),
+    project_slug: z.string().optional().describe(PROJECT_SLUG_DESCRIPTION),
+});
+const UpdateIdeaSchema = z.object({
+    idea_id: refIdString().describe('The idea refId (number)'),
+    title: z.string().optional().describe('Updated title'),
+    content: z.string().optional().describe('Updated content (markdown)'),
+    stage: z.string().optional().describe('New stage: spark, exploring, building, shipped or parked'),
+    project_slug: z.string().optional().describe(PROJECT_SLUG_DESCRIPTION),
+});
+const BoostIdeaSchema = z.object({
+    idea_id: refIdString().describe('The idea refId (number)'),
+    project_slug: z.string().optional().describe(PROJECT_SLUG_DESCRIPTION),
+});
 // Comment schemas
 const ListWorkItemCommentsSchema = z.object({
     work_item_id: refIdString().describe('The work item refId (number)'),
@@ -831,14 +864,16 @@ class WolfpackMCPServer {
                 await this.fetchCapabilities();
             }
             return {
-                tools: [
+                // The catalogue carries a token where the product's name belongs (#2466); it is
+                // filled in here, as the tools are advertised.
+                tools: withProductName([
                     ...stdioTools(this.capabilities, this.permissions),
                     ...(this.capabilities.includes('agent_self') ? AGENT_SELF_TOOLS : []),
                     ...(this.capabilities.includes('agent_memory') ? AGENT_MEMORY_TOOLS : []),
                     ...(this.capabilities.includes('agent_observer') ? AGENT_OBSERVE_TOOLS : []),
                     ...(this.capabilities.includes('agent_builder') ? AGENT_BUILDER_TOOLS : []),
                     ...(this.capabilities.includes('browser_control') ? BROWSER_TOOLS : []),
-                ],
+                ], productName),
             };
         });
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -1508,6 +1543,71 @@ class WolfpackMCPServer {
                             ],
                         };
                     }
+                    // Idea handlers (the Idea Factory)
+                    case 'list_ideas': {
+                        const parsed = ListIdeasSchema.parse(args);
+                        const result = await this.client.listIdeas({
+                            teamSlug: parsed.project_slug || this.client.getProjectSlug() || undefined,
+                            sort: parsed.sort,
+                            limit: parsed.limit,
+                            offset: parsed.offset,
+                        });
+                        const spent = result.boostSpentToday
+                            ? 'Your boost for today in this project is already spent.'
+                            : 'Your boost for today in this project is unspent.';
+                        let text = `${spent}\n\n${JSON.stringify(stripUuids(result.items), null, 2)}`;
+                        if (result.total > result.items.length) {
+                            text = `Note: Showing ${result.items.length} of ${result.total} ideas. Use limit/offset for pagination.\n\n${text}`;
+                        }
+                        return { content: [{ type: 'text', text }] };
+                    }
+                    case 'get_idea': {
+                        const parsed = GetIdeaSchema.parse(args);
+                        const idea = await this.client.getIdea(parsed.idea_id, parsed.project_slug || this.client.getProjectSlug() || undefined);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(stripUuids(idea), null, 2) }],
+                        };
+                    }
+                    case 'create_idea': {
+                        const parsed = CreateIdeaSchema.parse(args);
+                        const idea = await this.client.createIdea({
+                            title: parsed.title,
+                            content: parsed.content,
+                            teamSlug: parsed.project_slug || this.client.getProjectSlug() || undefined,
+                        });
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Created idea #${idea.refId}: ${idea.title}\n\n${JSON.stringify(stripUuids(idea), null, 2)}`,
+                                },
+                            ],
+                        };
+                    }
+                    case 'update_idea': {
+                        const parsed = UpdateIdeaSchema.parse(args);
+                        const idea = await this.client.updateIdea(parsed.idea_id, { title: parsed.title, content: parsed.content, stage: parsed.stage }, parsed.project_slug || this.client.getProjectSlug() || undefined);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Updated idea #${idea.refId}: ${idea.title} (${idea.stage})\n\n${JSON.stringify(stripUuids(idea), null, 2)}`,
+                                },
+                            ],
+                        };
+                    }
+                    case 'boost_idea': {
+                        const parsed = BoostIdeaSchema.parse(args);
+                        const idea = await this.client.boostIdea(parsed.idea_id, parsed.project_slug || this.client.getProjectSlug() || undefined);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Boosted idea #${idea.refId}: ${idea.title} now has ${idea.boostCount} boost(s). That was your boost for today in this project.`,
+                                },
+                            ],
+                        };
+                    }
                     // Comment handlers
                     case 'list_work_item_comments': {
                         const parsed = ListWorkItemCommentsSchema.parse(args);
@@ -2072,7 +2172,7 @@ class WolfpackMCPServer {
         // Connect stdio transport FIRST so MCP clients don't deadlock waiting for initialize
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
-        console.error(`Wolfpack MCP Server v${CURRENT_VERSION} started`);
+        console.error(`${productName} MCP Server v${CURRENT_VERSION} started`);
         if (!this.capabilitiesLoaded) {
             console.error('Starting with base tools only; retrying capabilities fetch in background');
             void this.recoverCapabilities();

package/dist/serverInstructions.js

@@ -1,3 +1,4 @@
+import { productName } from './brand.js';
 /**
  * Server instructions, returned in the MCP `initialize` result.
  *
@@ -12,9 +13,9 @@
  * server — the two servers have no shared package, and already keep their tool
  * descriptions in step by hand.
  */
-export const SERVER_INSTRUCTIONS = `Wolfpack is this project's tracker. Its references override the usual GitHub reading of "#N".
+export const SERVER_INSTRUCTIONS = `${productName} is this project's tracker. Its references override the usual GitHub reading of "#N".
 
-- A bare "#123" — "work on #123", "look at #42" — is ALWAYS a Wolfpack work item. Call get_work_item. Do not run \`gh issue view\`, and do not search GitHub for it.
+- A bare "#123" — "work on #123", "look at #42" — is ALWAYS a ${productName} work item. Call get_work_item. Do not run \`gh issue view\`, and do not search GitHub for it.
 - Read a number as a GitHub issue or pull request only when the user says GitHub, PR, or gh — "the GitHub issue #123", "PR #123".
-- Every other Wolfpack type needs its prefix and is never a bare number: #i123 issues, #r123 roadmap/initiatives, #j123 journal entries, #c123 cases, #p123 procedures. Wiki pages are addressed by path, e.g. /docs/setup.
-- On its own, "issue" means a Wolfpack issue (#i123). A GitHub issue is only ever called a GitHub issue.`;
+- Every other ${productName} type needs its prefix and is never a bare number: #i123 issues, #r123 roadmap/initiatives, #j123 journal entries, #c123 cases, #p123 procedures. Wiki pages are addressed by path, e.g. /docs/setup.
+- On its own, "issue" means a ${productName} issue (#i123). A GitHub issue is only ever called a GitHub issue.`;

package/dist/toolCatalogue.js

@@ -21,6 +21,22 @@
  * `agentBuilderTools.ts`, `agentSelfTools.ts`, `browserTools.ts`), so they have
  * no second declaration to drift from.
  */
+/**
+ * The token a description carries where the product's name belongs (#2466).
+ *
+ * The catalogue is serialised into the backend's generated copy, so a description cannot
+ * interpolate the name — it would be baked in at generation time, and the copy would go
+ * stale on a rename with nothing to notice. Each transport fills the token in as it
+ * advertises its tools instead.
+ */
+export const PRODUCT_NAME_TOKEN = '__PRODUCT_NAME__';
+/** The same tools, as a person reading their client's tool list should see them. */
+export function withProductName(tools, productName) {
+    return tools.map((tool) => ({
+        ...tool,
+        description: tool.description?.split(PRODUCT_NAME_TOKEN).join(productName),
+    }));
+}
 // Cross-reference syntax for linking between content items in markdown fields
 const CONTENT_LINKING_HELP = 'CROSS-REFERENCES: In any markdown content, you can link to other items using these patterns: ' +
     '#123, #w123, or #work-123 for work items (DEFAULT — bare #N always means a work item), ' +
@@ -89,9 +105,9 @@ export const TOOL_CATALOGUE = [
         // Checks each entity type itself and drops the types it may not read, so a
         // key holding only `mcp:wiki:read` still searches pages.
         permission: null,
-        description: 'Ranked full-text search across project content: wiki pages, work items, cases, journal entries, issues and the Wolfpack user manual. ' +
+        description: 'Ranked full-text search across project content: wiki pages, work items, cases, journal entries, issues and the __PRODUCT_NAME__ user manual. ' +
             'Title matches outrank body matches; results include a snippet, entity type, and refId/slug for follow-up calls ' +
-            '(get_work_item, get_issue, get_wiki_page, ...). Results with entityType "manual" are user manual sections — platform documentation on how Wolfpack features work. ' +
+            '(get_work_item, get_issue, get_wiki_page, ...). Results with entityType "manual" are user manual sections — platform documentation on how __PRODUCT_NAME__ features work. ' +
             'Use this to find existing content before creating new items, or when the user asks to "find" or "look up" something without saying where it lives.',
         inputSchema: {
             type: 'object',
@@ -132,7 +148,7 @@ export const TOOL_CATALOGUE = [
             'with a non-empty blockedBy is NOT claimable however approved it is — take the work it names ' +
             'first; the response says so too. ' +
             'TERMINOLOGY: "board" and "kanban" are synonymous - both refer to the Kanban board of work items. ' +
-            'The board has columns: "new" (to do), "doing" (in progress), "review" (pending review), "ready" (code done, awaiting deployment), "blocked", "completed" (deployed). ' +
+            'The board has columns: "new" (to do), "doing" (in progress), "paused" (set aside by a human), "blocked", "review" (pending review), "ready" (code done, awaiting deployment), "completed" (deployed). ' +
             'The "backlog" or "pending" status represents items not yet on the board. ' +
             'By default, completed/closed items are excluded - use status="all" to include them. ' +
             'IMPORTANT: Work items are NOT the same as issues. Work items live on the Kanban board/backlog. ' +
@@ -147,7 +163,7 @@ export const TOOL_CATALOGUE = [
                 },
                 status: {
                     type: 'string',
-                    description: 'Filter by status. Board columns: "new", "doing", "review", "ready", "blocked", "completed". ' +
+                    description: 'Filter by status. Board columns: "new", "doing", "paused", "blocked", "review", "ready", "completed". ' +
                         'Use "pending" or "backlog" for backlog items not on board. ' +
                         'Use "all" to include completed/closed items. Default excludes completed/closed.',
                 },
@@ -208,8 +224,9 @@ export const TOOL_CATALOGUE = [
             'WORKFLOW: When asked to work on an item, check its status and follow the required state transitions ' +
             '(pending→pull first, new→doing, review→doing when you are picking the work back up, ' +
             'ready/completed/closed→new→doing, then review when done). ' +
-            'AGENTS: a "blocked" item is not yours to restart — a human clears the blocker. Leave it where it is, ' +
-            'comment if you can help clear it, and take the next claimable item instead. ' +
+            'AGENTS: a "blocked" or "paused" item is not yours to restart — a human clears the blocker, and a ' +
+            'human decides when paused work resumes. Leave it where it is, comment if you can help, and take ' +
+            'the next claimable item instead. ' +
             'PLANNING: Check if the description contains a plan (markdown checklist). If not, APPEND one using update_work_progress - preserve all original description text and add your plan below a "---" separator. ' +
             'FORMS: Procedure-created work items may include formDefinition (field definitions with name, label, type, required, options) and formValues (current values). Use submit_work_item_form to fill in form values. ' +
             'REVIEW CHECKS: items under review may carry review checks (code-review, security-review, ...); see list_work_item_checks and claim/complete_work_item_check. ' +
@@ -264,7 +281,8 @@ export const TOOL_CATALOGUE = [
             '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. ' +
-            'Nor can you move an item OUT of "blocked": clearing a blocker is a human decision. ' +
+            'Nor can you move an item OUT of "blocked" or "paused": clearing a blocker, and resuming work a ' +
+            'human set aside, are human decisions. ' +
             'Take it with pull_work_item, which assigns it to you and puts it in "doing"; that is ' +
             'what makes the board show who is working on what. ' +
             'When moving to "review", add a completion comment via create_work_item_comment. When moving to "blocked", add a comment explaining the blocker. ' +
@@ -291,6 +309,7 @@ export const TOOL_CATALOGUE = [
                         'pending',
                         'new',
                         'doing',
+                        'paused',
                         'blocked',
                         'review',
                         'ready',
@@ -803,6 +822,7 @@ export const TOOL_CATALOGUE = [
                         'pending',
                         'new',
                         'doing',
+                        'paused',
                         'blocked',
                         'review',
                         'ready',
@@ -810,7 +830,7 @@ export const TOOL_CATALOGUE = [
                         'closed',
                         'archived',
                     ],
-                    description: 'Initial status: "pending" (backlog), "new" (to do), "doing", "review", "ready", "blocked", "completed", "closed", "archived". Defaults to "new".',
+                    description: 'Initial status: "pending" (backlog), "new" (to do), "doing", "paused", "blocked", "review", "ready", "completed", "closed", "archived". Defaults to "new".',
                 },
                 priority: {
                     type: 'number',
@@ -1126,6 +1146,124 @@ export const TOOL_CATALOGUE = [
             required: ['entry_id'],
         },
     },
+    // Idea Factory tools (#2473). Gated on the `ideas` capability, which the backend
+    // grants a key holding mcp:ideas:read once the `idea-factory` flag is on for it.
+    // No archive tool: archiving is the Idea Factory's delete, and MCP does not
+    // surface deletes (packages/mcp/CLAUDE.md).
+    {
+        name: 'list_ideas',
+        permission: 'mcp:ideas:read',
+        capability: 'ideas',
+        description: 'List the live ideas in a project (the Idea Factory). Use when user asks about "ideas", ' +
+            '"the idea factory", "what has been suggested", or "what are we thinking about". ' +
+            'Each idea carries a stage (spark, exploring, building, shipped, parked) and a boostCount — ' +
+            'the number of members who have voted for it. The response also says whether your own boost ' +
+            'for today in this project has already been spent.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sort: {
+                    type: 'string',
+                    description: 'Ordering: "popular" (default, most boosted first), "updated", or "newest"',
+                },
+                limit: { type: 'number', description: 'Maximum number of ideas to return' },
+                offset: { type: 'number', description: 'Number of ideas to skip' },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_idea',
+        permission: 'mcp:ideas:read',
+        capability: 'ideas',
+        description: 'Get a single idea by its refId, with its full content, stage, tags, boost count and the ' +
+            'refIds of any work items being built from it.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                idea_id: { type: 'string', description: 'The idea refId (number)' },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                },
+            },
+            required: ['idea_id'],
+        },
+    },
+    {
+        name: 'create_idea',
+        permission: 'mcp:ideas:create',
+        capability: 'ideas',
+        description: 'Raise a new idea in the Idea Factory. Use when user wants to "suggest", "raise an idea", ' +
+            '"add to the idea factory", or "capture a thought". A new idea starts at the "spark" stage ' +
+            'with no boosts. Requires mcp:ideas:create permission. ' +
+            CONTENT_LINKING_HELP,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string', description: 'Idea title' },
+                content: { type: 'string', description: 'Idea content (markdown)' },
+                // No tag_ids: the service takes tag UUIDs and the MCP surface strips UUIDs
+                // from every response, so an agent never holds one to send back. Tag an
+                // idea in the UI.
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                },
+            },
+            required: ['title', 'content'],
+        },
+    },
+    {
+        name: 'update_idea',
+        permission: 'mcp:ideas:update',
+        capability: 'ideas',
+        description: 'Update an idea, or move it to another stage. The stages are "spark" (just raised), ' +
+            '"exploring", "building", "shipped" and "parked" — moving an idea along is how the project ' +
+            'sees what became of it. Requires mcp:ideas:update permission. ' +
+            CONTENT_LINKING_HELP,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                idea_id: { type: 'string', description: 'The idea refId (number)' },
+                title: { type: 'string', description: 'Updated title' },
+                content: { type: 'string', description: 'Updated content (markdown)' },
+                stage: {
+                    type: 'string',
+                    description: 'New stage: spark, exploring, building, shipped or parked',
+                },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                },
+            },
+            required: ['idea_id'],
+        },
+    },
+    {
+        name: 'boost_idea',
+        permission: 'mcp:ideas:boost',
+        capability: 'ideas',
+        description: 'Vote for an idea by spending your boost. Use when user wants to "vote for", "boost", ' +
+            '"back" or "+1" an idea. You get ONE boost per project per day, whichever idea you spend ' +
+            'it on, so it is a choice between ideas rather than a click — spending it again the same ' +
+            'day is refused rather than counted. Requires mcp:ideas:boost permission, which is separate ' +
+            'from mcp:ideas:update: voting is participation, not editing.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                idea_id: { type: 'string', description: 'The idea refId (number)' },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                },
+            },
+            required: ['idea_id'],
+        },
+    },
     // Comment tools
     {
         name: 'list_work_item_comments',

package/dist/toolCatalogue.test.js

@@ -1,7 +1,8 @@
 import { describe, it, expect } from 'vitest';
 import { readFileSync } from 'fs';
 import { join } from 'path';
-import { TOOL_CATALOGUE, remoteTools, remoteToolPermissions, stdioTools } from './toolCatalogue.js';
+import * as catalogue from './toolCatalogue.js';
+import { TOOL_CATALOGUE, remoteTools, stdioTools } from './toolCatalogue.js';
 import { BROWSER_TOOLS } from './browserTools.js';
 // @ts-expect-error — a plain .mjs build script, deliberately not part of this program
 import { render, GENERATED_PATH } from '../../../scripts/generate-mcp-catalogue.mjs';
@@ -16,7 +17,9 @@ const repoFile = (path) => readFileSync(join(__dirname, '../../..', path), 'utf8
 describe('the MCP tool catalogue', () => {
     it("is what the backend's generated copy holds", () => {
         // The one check that makes the other declaration a copy rather than a rival.
-        expect(readFileSync(GENERATED_PATH, 'utf8')).toBe(render({ remoteTools, remoteToolPermissions }));
+        // The whole module, exactly as the generator imports it: passing named exports
+        // one by one is how the copy went stale when the generator grew a new one (#2466).
+        expect(readFileSync(GENERATED_PATH, 'utf8')).toBe(render(catalogue));
     });
     it('gives every tool a name no other tool has', () => {
         const names = TOOL_CATALOGUE.map((t) => t.name);
@@ -58,13 +61,16 @@ describe('the MCP tool catalogue', () => {
             .map((param) => `${tool.name}.${param}`));
         expect(unforwarded).toEqual([]);
     });
-    it('offers the procedure tools over stdio only to a key with that capability', () => {
-        const withProcedures = stdioTools(['procedures']).map((t) => t.name);
+    // Every capability in the catalogue, not just `procedures`: a family added with
+    // its `capability` left off is offered to every key, and nothing else notices.
+    it.each([...new Set(TOOL_CATALOGUE.map((t) => t.capability).filter(Boolean))])('offers the %s tools over stdio only to a key with that capability', (capability) => {
+        const gated = TOOL_CATALOGUE.filter((t) => t.capability === capability).map((t) => t.name);
+        const withIt = stdioTools([capability]).map((t) => t.name);
         const without = stdioTools([]).map((t) => t.name);
-        expect(withProcedures).toContain('start_case');
-        expect(without).not.toContain('start_case');
+        expect(withIt).toEqual(expect.arrayContaining(gated));
+        gated.forEach((name) => expect(without).not.toContain(name));
         // Gating is the only difference: nothing else drops out.
-        expect(withProcedures.length - without.length).toBe(TOOL_CATALOGUE.filter((t) => t.capability === 'procedures').length);
+        expect(withIt.length - without.length).toBe(gated.length);
     });
     it('offers a tool over stdio only to a key holding its scope', () => {
         // #2428 — the list told an agent it could do things the 403 then refused.

package/package.json

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