@orboto/mcp 0.230.6 → 0.230.8

package/dist/channel-toolset.test.js

@@ -45,17 +45,31 @@ describe('resolveToolset / toolInToolset - channel', () => {
     });
 });
 describe('ORB-2210 - the channel toolset', () => {
-    it('starts, answers initialize, registers no tool, prompt or resource, and fetches no rules at connect', async () => {
+    it('starts, answers initialize, offers no tool, prompt or resource, and fetches no rules at connect', async () => {
         const { server, client, fetchSpy } = await connectChannelServer();
         expect(client.getServerVersion()?.name).toBe('orboto');
-        expect(client.getServerCapabilities()?.tools).toBeUndefined();
-        expect(client.getServerCapabilities()?.prompts).toBeUndefined();
-        expect(client.getServerCapabilities()?.resources).toBeUndefined();
+        expect(client.getServerCapabilities()?.tools).toEqual({});
+        expect(client.getServerCapabilities()?.prompts).toEqual({});
+        expect(client.getServerCapabilities()?.resources).toEqual({});
         expect(client.getServerCapabilities()?.experimental).toHaveProperty(CHANNEL_CAPABILITY);
+        expect((await client.listTools()).tools).toEqual([]);
+        expect((await client.listPrompts()).prompts).toEqual([]);
+        expect((await client.listResources()).resources).toEqual([]);
+        expect((await client.listResourceTemplates()).resourceTemplates).toEqual([]);
         expect(fetchSpy).not.toHaveBeenCalled();
         await client.close();
         await server.close();
     });
+    it('ORB-2669 - a name nothing registered keeps the not-found answers of the other toolsets', async () => {
+        const { server, client } = await connectChannelServer();
+        const result = await client.callTool({ name: 'orboto_get_ticket', arguments: {} });
+        expect(result.isError).toBe(true);
+        expect(result.content).toEqual([{ type: 'text', text: 'MCP error -32602: Tool orboto_get_ticket not found' }]);
+        await expect(client.getPrompt({ name: 'plan-sprint' })).rejects.toMatchObject({ code: -32602 });
+        await expect(client.readResource({ uri: 'orboto://rules' })).rejects.toMatchObject({ code: -32602 });
+        await client.close();
+        await server.close();
+    });
     it('instructions point at the CLI, the scope command and the way back to the tools', async () => {
         const { server, client } = await connectChannelServer();
         const text = client.getInstructions() ?? '';

package/dist/empty-surfaces.js

@@ -0,0 +1,21 @@
+import { CallToolRequestSchema, ErrorCode, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, McpError, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+/** Declared at construction: the SDK refuses a request handler whose capability is not declared. */
+export const EMPTY_SURFACE_CAPABILITIES = { tools: {}, prompts: {}, resources: {} };
+/** Empty lists, and the not-found answers the SDK gives for a name nothing registered. */
+export function registerEmptySurfaces(server) {
+    const low = server.server;
+    low.setRequestHandler(ListToolsRequestSchema, () => ({ tools: [] }));
+    low.setRequestHandler(CallToolRequestSchema, (req) => ({
+        content: [{ type: 'text', text: new McpError(ErrorCode.InvalidParams, `Tool ${req.params.name} not found`).message }],
+        isError: true,
+    }));
+    low.setRequestHandler(ListPromptsRequestSchema, () => ({ prompts: [] }));
+    low.setRequestHandler(GetPromptRequestSchema, (req) => {
+        throw new McpError(ErrorCode.InvalidParams, `Prompt ${req.params.name} not found`);
+    });
+    low.setRequestHandler(ListResourcesRequestSchema, () => ({ resources: [] }));
+    low.setRequestHandler(ListResourceTemplatesRequestSchema, () => ({ resourceTemplates: [] }));
+    low.setRequestHandler(ReadResourceRequestSchema, (req) => {
+        throw new McpError(ErrorCode.InvalidParams, `Resource ${req.params.uri} not found`);
+    });
+}

package/dist/server.js

@@ -3,10 +3,12 @@
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { VERSION } from './version.js';
+import { assertZodCollectionBounds, installZodCollectionBounds } from './zod-bounds.js';
 import { SubscribeRequestSchema, UnsubscribeRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { OrbotoClient } from './orboto-client.js';
 import { registerOrbotoResources } from './resources.js';
 import { registerOrbotoPrompts } from './prompts.js';
+import { EMPTY_SURFACE_CAPABILITIES, registerEmptySurfaces } from './empty-surfaces.js';
 import { registerWithMetrics } from './with-metrics.js';
 import { CHANNEL_TOOLSET_INSTRUCTIONS, CHANNEL_TOOLSET_WAKE_INSTRUCTIONS, resolveToolset, toolInToolset } from './toolset.js';
 import { createNudgeState } from './session-nudge.js';
@@ -146,6 +148,8 @@ export function assembleInstructions(head, workingRules, budget = INSTRUCTIONS_B
     return `${head}\n\n${RULES_HEADING}${kept}${TRUNCATION_MARKER}`;
 }
 export async function buildOrbotoMcpServer(opts) {
+    installZodCollectionBounds();
+    assertZodCollectionBounds();
     const client = new OrbotoClient(opts);
     const toolset = resolveToolset(opts.toolset, process.env.ORBOTO_MCP_TOOLSET);
     let workingRules = FALLBACK_WORKING_RULES;
@@ -167,7 +171,7 @@ export async function buildOrbotoMcpServer(opts) {
     const channelHint = opts.channel ? [CHANNEL_INSTRUCTIONS] : [];
     const server = new McpServer({ name: 'orboto', version: VERSION }, {
         capabilities: {
-            ...(toolset === 'channel' ? {} : { resources: { subscribe: true, listChanged: true } }),
+            ...(toolset === 'channel' ? EMPTY_SURFACE_CAPABILITIES : { resources: { subscribe: true, listChanged: true } }),
             ...(opts.channel ? { experimental: { [CHANNEL_CAPABILITY]: {} } } : {}),
         },
         instructions: toolset === 'channel'
@@ -381,8 +385,10 @@ export async function buildOrbotoMcpServer(opts) {
     reg('orboto_admin_translation_revert', revertTranslationToolConfig, makeAdminRevertTranslationHandler(client));
     reg('orboto_admin_agent_drift_list', listAgentDriftToolConfig, makeListAgentDriftHandler(client));
     reg('orboto_admin_agent_drift_resolve', resolveAgentDriftToolConfig, makeResolveAgentDriftHandler(client));
-    if (toolset === 'channel')
+    if (toolset === 'channel') {
+        registerEmptySurfaces(server);
         return server;
+    }
     registerOrbotoResources(server, client);
     registerOrbotoPrompts(server);
     if (opts.subscriptions) {

package/dist/test/stdio-probe.js

@@ -0,0 +1,79 @@
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { hermeticHome, hermeticSpawnEnv } from './hermetic-cli-env.js';
+const mcpRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+/** ORB-2669 - the conversation a client such as Kimi Code opens with, over the real stdio entry: initialize, initialized, the three list methods without a capability check, one call of a tool that does not exist. */
+export async function probeStdioServer(env, timeoutMs = 25_000) {
+    const api = createServer((req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        if (req.url?.startsWith('/system/mcp/status')) {
+            res.end(JSON.stringify({ enabled: true, mcpUseGranted: true, userMcpEnabled: true, userEmail: 'probe@example.test' }));
+            return;
+        }
+        res.statusCode = 404;
+        res.end('{}');
+    });
+    await new Promise((ok) => api.listen(0, '127.0.0.1', ok));
+    const address = api.address();
+    if (!address || typeof address === 'string')
+        throw new Error('probe API address missing');
+    const child = spawn(process.execPath, ['--import', 'tsx', 'src/index.ts'], {
+        cwd: mcpRoot,
+        env: hermeticSpawnEnv({
+            home: hermeticHome('mcp-stdio-probe'),
+            env: { ORBOTO_API_URL: `http://127.0.0.1:${address.port}`, ORBOTO_API_KEY: 'orb_probe', ORBOTO_AUTH: 'pat', ...env },
+        }),
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const lines = [];
+    const answers = new Map();
+    const waiting = new Map();
+    let buffer = '', stderr = '';
+    child.stdout.on('data', (chunk) => {
+        buffer += chunk.toString();
+        for (let cut = buffer.indexOf('\n'); cut >= 0; cut = buffer.indexOf('\n')) {
+            const line = buffer.slice(0, cut).trim();
+            buffer = buffer.slice(cut + 1);
+            if (!line)
+                continue;
+            lines.push(line);
+            const message = JSON.parse(line);
+            if (typeof message.id === 'number') {
+                answers.set(message.id, { result: message.result, error: message.error });
+                waiting.get(message.id)?.();
+            }
+        }
+    });
+    child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+    const exited = new Promise((_, no) => child.once('exit', (code) => no(new Error(`the MCP server exited with ${code} before it answered: ${stderr.slice(-600)}`))));
+    exited.catch(() => undefined);
+    const send = (message) => { child.stdin.write(`${JSON.stringify(message)}\n`); };
+    const answer = (id) => Promise.race([
+        new Promise((ok) => {
+            const have = answers.get(id);
+            if (have)
+                ok(have);
+            else
+                waiting.set(id, () => ok(answers.get(id)));
+        }),
+        exited,
+        new Promise((_, no) => setTimeout(() => no(new Error(`no answer to request ${id} in ${timeoutMs} ms: ${stderr.slice(-600)}`)), timeoutMs).unref()),
+    ]);
+    try {
+        send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'stdio-probe', version: 'probe' } } });
+        const initialize = await answer(1);
+        send({ jsonrpc: '2.0', method: 'notifications/initialized' });
+        send({ jsonrpc: '2.0', id: 2, method: 'tools/list' });
+        send({ jsonrpc: '2.0', id: 3, method: 'prompts/list' });
+        send({ jsonrpc: '2.0', id: 4, method: 'resources/list' });
+        send({ jsonrpc: '2.0', id: 5, method: 'tools/call', params: { name: 'orboto_no_such_tool', arguments: {} } });
+        const [tools, prompts, resources, unknownTool] = await Promise.all([answer(2), answer(3), answer(4), answer(5)]);
+        return { initialize, lists: { 'tools/list': tools, 'prompts/list': prompts, 'resources/list': resources }, unknownTool, lines };
+    }
+    finally {
+        child.kill('SIGKILL');
+        await new Promise((ok) => api.close(() => ok()));
+    }
+}

package/dist/tools/agent-coordination.js

@@ -17,7 +17,7 @@ export const agentHeartbeatToolConfig = {
         scope: AgentSessionScopeSchema.optional(),
         status: z.enum(['idle', 'working', 'blocked']).optional(),
         workingOnTicketId: z.string().uuid().nullable().optional(),
-        capabilities: z.array(z.string()).optional(),
+        capabilities: z.array(z.string()).max(200).optional(),
         clientInfo: z.object({
             name: z.string().optional(),
             version: z.string().optional(),

package/dist/tools/agent-session-scope.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 /** ORB-2136 - standalone mirror of `@orboto/shared-schema` agent-session-scope (the MCP package does not depend on it). */
 export const AgentSessionRoleSchema = z.enum(['integrator', 'lead', 'worker', 'spec', 'review', 'coordinator']);
 export const AgentSessionScopeSchema = z.object({
-    projectKeys: z.array(z.string()).optional(),
-    ticketKeys: z.array(z.string()).optional(),
+    projectKeys: z.array(z.string()).max(50).optional(),
+    ticketKeys: z.array(z.string()).max(200).optional(),
     role: AgentSessionRoleSchema.optional(),
 });

package/dist/tools/api-call.js

@@ -9,6 +9,7 @@
  * instead of surfacing as an opaque tool failure.
  */
 import { z } from 'zod';
+import { boundedRecord } from '../zod-bounds.js';
 import { mcpInstanceToken } from './shared.js';
 export const apiCallToolConfig = {
     title: 'Call any orboto REST endpoint',
@@ -23,7 +24,7 @@ export const apiCallToolConfig = {
         method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']),
         path: z.string().min(1).max(500)
             .describe('Route path, e.g. "/projects/<uuid>/milestones". No query string.'),
-        query: z.record(z.union([z.string(), z.number(), z.boolean(), z.array(z.string())])).optional()
+        query: boundedRecord(z.string(), z.union([z.string(), z.number(), z.boolean(), z.array(z.string()).max(200)]), 100).optional()
             .describe('Query parameters as an object.'),
         body: z.union([z.record(z.unknown()), z.array(z.unknown()), z.string(), z.number(), z.boolean()]).optional()
             .describe('JSON body - a real object/array, not a stringified one.'),

package/dist/tools/bulk-create.js

@@ -14,8 +14,8 @@ const TicketDraftSchema = z.object({
     priority: z.enum(['blocker', 'high', 'normal', 'low', 'trivial']).optional().describe('Default: normal.'),
     deliveryMode: z.enum(['implementation', 'docs', 'review', 'admin', 'epic']).optional(),
     milestone: z.string().optional().describe('Key ("ORB-M3"), name, or UUID; overrides the call-level one.'),
-    assigneeEmails: z.array(z.string().email()).optional(),
-    labels: z.array(z.string()).optional().describe('Existing label names.'),
+    assigneeEmails: z.array(z.string().email()).max(100).optional(),
+    labels: z.array(z.string()).max(100).optional().describe('Existing label names.'),
     parentTicketKey: z.string().optional(),
     dueDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
     isPrivate: z.boolean().optional(),

package/dist/tools/doc-edits.js

@@ -173,7 +173,7 @@ export const editDocSectionToolConfig = {
     inputSchema: z.object({
         docId: z.string().min(1).describe('Doc UUID or human-readable key (ORB-D12 / DOC-5). Find via orboto_search_docs.'),
         sectionOps: z.array(z.object({
-            headingPath: z.array(z.string().min(1)).min(1).describe('Ordered heading breadcrumb, top-down. Exact + case-sensitive.'),
+            headingPath: z.array(z.string().min(1)).min(1).max(20).describe('Ordered heading breadcrumb, top-down. Exact + case-sensitive.'),
             op: z.enum(['replace', 'append', 'insertAfter']).describe('replace body / append to body / insert directly below the heading line.'),
             content: z.string().describe('New markdown content for the op.'),
         })).min(1).max(100).describe('Applied sequentially after any string edits.'),

package/dist/tools/docs.js

@@ -154,7 +154,7 @@ export const updateDocSpaceToolConfig = {
         isPublic: z.boolean().optional().describe('DEPRECATED - use guestsVisible.'),
         visibility: z.enum(['workspace', 'project_members', 'restricted']).optional().describe('Read gate: workspace = every internal member, project_members = members with doc:view (project spaces), restricted = allowlist. Needs manage rights.'),
         guestsVisible: z.boolean().optional().describe('Explicit guest (external user) opt-in. Requires manage rights.'),
-        memberIds: z.array(z.string().uuid()).optional().describe('Replaces the restricted-space allowlist. Requires manage rights.'),
+        memberIds: z.array(z.string().uuid()).max(5000).optional().describe('Replaces the restricted-space allowlist. Requires manage rights.'),
         slug: z.string().min(1).max(100).regex(/^[a-z0-9-]+$/).optional(),
     }).shape,
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },

package/dist/tools/get-ticket.js

@@ -13,7 +13,7 @@ export const getTicketToolConfig = {
     description: 'A ticket\'s decision card: description, status, priority, milestone, assignees, labels, dates, checklist progress, parent, open dependency edges and COUNTS of what is omitted (`include` opts blocks in). Comments: newest first, 3 newest in full, older shortened; `full` all, `commentId` one. Input: ticket key like "ACME-42".',
     inputSchema: z.object({
         ticketKey: z.string().min(3).describe('Key like "ACME-42".'),
-        include: z.array(z.enum(['comments', 'git', 'attachments', 'children', 'raci', 'checklistItems']))
+        include: z.array(z.enum(['comments', 'git', 'attachments', 'children', 'raci', 'checklistItems'])).max(20)
             .optional()
             .describe('Blocks to inline.'),
         full: z.boolean().optional().describe('Comments in full.'),

package/dist/tools/search.js

@@ -11,7 +11,7 @@ export const searchToolConfig = {
     description: 'Search tickets, comments and docs; `types` adds projects, milestones, spaces, customers. Content matches full text, jump types match key and name; `types` defaults to ticket, comment, doc. Honours the caller\'s visibility - private tickets and internal comments never appear unless the caller can already see them. Recall (ORB-1695): when the strict all-terms pass finds nothing, the server automatically retries with an OR-relaxed pass plus semantic (embedding) recall - the response\'s `pass` field says which pass produced the hits, and relaxed-pass hits deserve a skeptical read (they matched SOME terms or only the meaning, not all terms). Still prefer a single distinctive STABLE token (file/component/error-string fragment like "AdminCodesPage") and search the SYMPTOM, not your intended fix.',
     inputSchema: z.object({
         query: z.string().min(1).describe('Search terms, e.g. "queue worker retry".'),
-        types: z.array(z.enum(SEARCH_TYPES)).optional(),
+        types: z.array(z.enum(SEARCH_TYPES)).max(20).optional(),
         projectKey: z.string().optional().describe('Restrict to one project.'),
         limit: z.number().int().min(1).max(50).default(15),
     }).shape,

package/dist/tools/spec-schemas.js

@@ -4,7 +4,7 @@ export const TicketSpecStateSchema = z.enum(['none', 'needs_spec', 'in_spec', 'r
 export const TicketListSortSchema = z.enum(['updated', 'created']);
 export const ProjectSpecSettingsSchema = z.object({
     enabled: z.boolean().optional(),
-    requiredTypes: z.array(z.enum(['epic', 'story', 'task', 'bug'])).optional(),
+    requiredTypes: z.array(z.enum(['epic', 'story', 'task', 'bug'])).max(20).optional(),
     releaseBy: z.enum(['agent', 'author']).optional(),
 }).strict();
 export function specGateFailure(body) {

package/dist/tools/ticket-schedules.js

@@ -51,8 +51,8 @@ export const scheduleTicketSessionToolConfig = {
         title: z.string().optional(),
         location: z.string().optional().describe('Free text - Zoom URL, room name, "remote".'),
         notes: z.string().optional(),
-        attendeeUserIds: z.array(z.string().uuid()).optional().describe('orboto attendee user UUIDs.'),
-        externalEmails: z.array(z.string().email()).optional().describe('External (non-orboto) guest emails.'),
+        attendeeUserIds: z.array(z.string().uuid()).max(500).optional().describe('orboto attendee user UUIDs.'),
+        externalEmails: z.array(z.string().email()).max(500).optional().describe('External (non-orboto) guest emails.'),
     }).shape,
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
 };

package/dist/tools/ticket-writes.js

@@ -67,8 +67,8 @@ export const createTicketToolConfig = {
         specState: TicketSpecStateSchema.optional(),
         deliveryMode: z.enum(['implementation', 'docs', 'review', 'admin', 'epic']).optional(),
         milestone: z.string().optional().describe('Key ("ORB-M3"), name, or UUID.'),
-        assigneeEmails: z.array(z.string().email()).optional().describe('Project-member emails.'),
-        labels: z.array(z.string()).optional(),
+        assigneeEmails: z.array(z.string().email()).max(100).optional().describe('Project-member emails.'),
+        labels: z.array(z.string()).max(100).optional(),
         parentTicketKey: z.string().optional().describe('Parent key - makes this a sub-ticket.'),
         dueDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
         isPrivate: z.boolean().optional(),

package/dist/tools/work-sessions.js

@@ -504,7 +504,7 @@ export const workSessionClaimsReleaseToolConfig = {
     description: 'Drop resource claims (or all) from your session without finishing it or touching lease and timer. Releasing a granted write claim immediately runs a grant pass, so the earliest queued waiter for that resource is promoted as part of this call - useful once you know you are done touching a subtree but are not done with the ticket. Omit `claims` to release everything the session holds.',
     inputSchema: z.object({
         sessionId: z.string().uuid().describe('The id returned by orboto_work_session_start.'),
-        claims: z.array(z.object({ kind: z.enum(['path', 'named']), value: z.string().min(1).max(500) })).optional()
+        claims: z.array(z.object({ kind: z.enum(['path', 'named']), value: z.string().min(1).max(500) })).max(500).optional()
             .describe('Which claims to release, matched by kind+value. Omit to release ALL claims on this session.'),
     }).shape,
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },

package/dist/toolset-list-methods.stdio.test.js

@@ -0,0 +1,53 @@
+/**
+ * ORB-2669 - every toolset answers tools/list, prompts/list and resources/list
+ * over the real stdio entry and declares the matching capabilities. Kimi Code
+ * lists without checking capabilities and dropped the `channel` server on -32601.
+ */
+import { describe, expect, it } from 'vitest';
+import { CHANNEL_CAPABILITY } from './inbox-channel.js';
+import { CHANNEL_TOOLSET_INSTRUCTIONS, CHANNEL_TOOLSET_WAKE_INSTRUCTIONS } from './toolset.js';
+import { probeStdioServer } from './test/stdio-probe.js';
+const PROBE_TIMEOUT_MS = 60_000;
+function listed(answer, key) {
+    const value = answer.result?.[key];
+    expect(Array.isArray(value), `${key} is a list`).toBe(true);
+    return value;
+}
+describe('ORB-2669 - the list methods over the stdio entry', () => {
+    it.each(['channel', 'minimal', 'curated', 'full'])('%s declares tools, prompts and resources and answers all three list methods', async (toolset) => {
+        const probe = await probeStdioServer({ ORBOTO_MCP_TOOLSET: toolset });
+        for (const method of ['tools/list', 'prompts/list', 'resources/list']) {
+            expect(probe.lists[method].error, `${toolset} ${method}`).toBeUndefined();
+        }
+        const capabilities = probe.initialize.result?.capabilities;
+        expect(capabilities).toHaveProperty('tools');
+        expect(capabilities).toHaveProperty('prompts');
+        expect(capabilities).toHaveProperty('resources');
+        const tools = listed(probe.lists['tools/list'], 'tools');
+        const prompts = listed(probe.lists['prompts/list'], 'prompts');
+        const resources = listed(probe.lists['resources/list'], 'resources');
+        if (toolset === 'channel') {
+            expect([tools.length, prompts.length, resources.length]).toEqual([0, 0, 0]);
+        }
+        else {
+            expect(tools.length).toBeGreaterThan(0);
+            expect(prompts.length).toBeGreaterThan(0);
+        }
+        expect(probe.unknownTool.error).toBeUndefined();
+        expect(probe.unknownTool.result).toMatchObject({ isError: true, content: [{ type: 'text', text: 'MCP error -32602: Tool orboto_no_such_tool not found' }] });
+    }, PROBE_TIMEOUT_MS);
+    it('channel keeps the wake capability and its CLI-first instructions next to the empty lists', async () => {
+        const probe = await probeStdioServer({ ORBOTO_MCP_TOOLSET: 'channel' });
+        expect(probe.initialize.result?.capabilities).toMatchObject({ experimental: { [CHANNEL_CAPABILITY]: {} }, tools: {}, prompts: {}, resources: {} });
+        expect(probe.initialize.result?.instructions).toBe([CHANNEL_TOOLSET_INSTRUCTIONS, CHANNEL_TOOLSET_WAKE_INSTRUCTIONS].join('\n\n'));
+    }, PROBE_TIMEOUT_MS);
+    it('the channel start can be switched off and the lists still answer', async () => {
+        const probe = await probeStdioServer({ ORBOTO_MCP_TOOLSET: 'channel', ORBOTO_MCP_CHANNEL: '0' });
+        for (const method of ['tools/list', 'prompts/list', 'resources/list']) {
+            expect(probe.lists[method].error, method).toBeUndefined();
+        }
+        const capabilities = probe.initialize.result?.capabilities;
+        expect(capabilities).not.toHaveProperty('experimental');
+        expect(capabilities).toHaveProperty('tools');
+    }, PROBE_TIMEOUT_MS);
+});

package/dist/zod-bounds.js

@@ -0,0 +1,157 @@
+/** ORB-2670 - GHSA-mrhx-c7xc-m3w5: an array over its `.max()` / `.length()` or a `boundedRecord` over its key limit fails with one issue before any element is parsed. */
+import * as zod from 'zod';
+const INSTALLED = Symbol.for('orboto.zodCollectionBounds');
+function exceedsKeyLimit(data, maxKeys) {
+    return !!data && typeof data === 'object' && !Array.isArray(data) && Object.keys(data).length > maxKeys;
+}
+/** Patches one zod module instance; a CommonJS program that also loads this ESM module passes its own `zod` too. */
+export function installZodCollectionBounds(runtime = zod) {
+    const { INVALID, ZodArray, ZodIssueCode, ZodRecord, addIssueToContext } = runtime;
+    const arrayProto = ZodArray.prototype;
+    if (arrayProto[INSTALLED])
+        return;
+    const parseArray = arrayProto._parse;
+    arrayProto._parse = function boundedArrayParse(input) {
+        const limit = this._def.exactLength ?? this._def.maxLength;
+        if (limit && Array.isArray(input.data) && input.data.length > limit.value) {
+            addIssueToContext(this._getOrReturnCtx(input), {
+                code: ZodIssueCode.too_big,
+                maximum: limit.value,
+                type: 'array',
+                inclusive: true,
+                exact: limit === this._def.exactLength,
+                message: limit.message,
+            });
+            return INVALID;
+        }
+        return parseArray.call(this, input);
+    };
+    arrayProto[INSTALLED] = true;
+    const recordProto = ZodRecord.prototype;
+    const parseRecord = recordProto._parse;
+    recordProto._parse = function boundedRecordParse(input) {
+        const maxKeys = this._def.maxKeys;
+        if (maxKeys !== undefined && exceedsKeyLimit(input.data, maxKeys)) {
+            addIssueToContext(this._getOrReturnCtx(input), {
+                code: ZodIssueCode.custom,
+                message: `Object must contain at most ${maxKeys} key(s)`,
+                params: { maxKeys },
+            });
+            return INVALID;
+        }
+        return parseRecord.call(this, input);
+    };
+    recordProto[INSTALLED] = true;
+}
+export function zodCollectionBoundsInstalled(runtime = zod) {
+    const marked = (proto) => proto[INSTALLED] === true;
+    return marked(runtime.ZodArray.prototype) && marked(runtime.ZodRecord.prototype);
+}
+/** Throws unless this module's zod and every passed instance carry the installed bounds. */
+export function assertZodCollectionBounds(...runtimes) {
+    if ([zod, ...runtimes].every((runtime) => zodCollectionBoundsInstalled(runtime)))
+        return;
+    throw new Error('zod collection bounds are not installed: call installZodCollectionBounds() for the ESM zod and installZodCollectionBounds(zod) for a CommonJS one before routes or tools register (ORB-2670, GHSA-mrhx-c7xc-m3w5).');
+}
+export function boundedRecord(keySchema, valueSchema, maxKeys) {
+    const base = zod.ZodRecord.create(keySchema, valueSchema);
+    return new zod.ZodRecord({ ...base._def, maxKeys });
+}
+function defOf(schema) {
+    return (schema?._def ?? {});
+}
+function isPassthrough(schema) {
+    const typeName = defOf(schema).typeName;
+    return typeName === 'ZodUnknown' || typeName === 'ZodAny';
+}
+function entriesCanFail(def) {
+    const key = defOf(def.keyType);
+    const plainKey = key.typeName === 'ZodString' && key.checks?.length === 0;
+    return !(isPassthrough(def.valueType) && plainKey);
+}
+/** Paths of every array, record, catchall, set, map and tuple rest whose unbounded entries can each fail. */
+export function findUnboundedCollections(schema, path = '$') {
+    const found = [];
+    const seen = new Set();
+    const walk = (node, at) => {
+        if (!node || typeof node !== 'object' || seen.has(node))
+            return;
+        seen.add(node);
+        const def = defOf(node);
+        switch (def.typeName) {
+            case 'ZodArray':
+                if (!def.maxLength && !def.exactLength && !isPassthrough(def.type))
+                    found.push(at);
+                walk(def.type, `${at}[]`);
+                return;
+            case 'ZodRecord':
+                if (def.maxKeys === undefined && entriesCanFail(def))
+                    found.push(at);
+                walk(def.keyType, `${at}{key}`);
+                walk(def.valueType, `${at}{}`);
+                return;
+            case 'ZodSet':
+                if (!def.maxSize)
+                    found.push(at);
+                walk(def.valueType, `${at}[]`);
+                return;
+            case 'ZodMap':
+                found.push(at);
+                walk(def.keyType, `${at}{key}`);
+                walk(def.valueType, `${at}{}`);
+                return;
+            case 'ZodTuple':
+                def.items.forEach((item, i) => walk(item, `${at}[${i}]`));
+                if (def.rest) {
+                    found.push(`${at}[...]`);
+                    walk(def.rest, `${at}[...]`);
+                }
+                return;
+            case 'ZodObject': {
+                const shape = def.shape();
+                for (const [key, child] of Object.entries(shape))
+                    walk(child, `${at}.${key}`);
+                if (defOf(def.catchall).typeName !== 'ZodNever') {
+                    if (!isPassthrough(def.catchall))
+                        found.push(`${at}.*`);
+                    walk(def.catchall, `${at}.*`);
+                }
+                return;
+            }
+            case 'ZodUnion':
+            case 'ZodDiscriminatedUnion':
+                for (const option of def.options)
+                    walk(option, at);
+                return;
+            case 'ZodIntersection':
+                walk(def.left, at);
+                walk(def.right, at);
+                return;
+            case 'ZodLazy':
+                walk(def.getter(), at);
+                return;
+            case 'ZodEffects':
+                walk(def.schema, at);
+                return;
+            case 'ZodPipeline':
+                walk(def.in, at);
+                walk(def.out, at);
+                return;
+            case 'ZodBranded':
+                walk(def.type, at);
+                return;
+            case 'ZodOptional':
+            case 'ZodNullable':
+            case 'ZodDefault':
+            case 'ZodCatch':
+            case 'ZodReadonly':
+            case 'ZodPromise':
+                walk(def.innerType ?? def.type, at);
+                return;
+            default:
+                return;
+        }
+    };
+    walk(schema, path);
+    return found;
+}

package/dist/zod-bounds.test.js

@@ -0,0 +1,39 @@
+/**
+ * ORB-2670 - every MCP tool input is length-bounded and the server installs the zod v3 short-circuit (GHSA-mrhx-c7xc-m3w5).
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
+import { buildOrbotoMcpServer } from './server.js';
+import { assertZodCollectionBounds, findUnboundedCollections, zodCollectionBoundsInstalled } from './zod-bounds.js';
+beforeEach(() => {
+    vi.restoreAllMocks();
+    vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('offline test'));
+    delete process.env.ORBOTO_MCP_TOOLSET;
+});
+afterEach(() => { vi.restoreAllMocks(); });
+describe('ORB-2670 - MCP tool inputs are bounded', () => {
+    it('no tool of the full toolset takes an unbounded array, record, catchall, set or map', async () => {
+        const server = await buildOrbotoMcpServer({ baseUrl: 'https://orboto.example.com', apiKey: 'orb_test', toolset: 'full' });
+        const tools = server._registeredTools;
+        expect(Object.keys(tools).length).toBeGreaterThan(150);
+        const found = Object.entries(tools).flatMap(([name, tool]) => findUnboundedCollections(tool.inputSchema, name));
+        expect(found).toEqual([]);
+        await server.close();
+    });
+    it('building the server installs the short-circuit: an oversized array yields one issue', async () => {
+        const server = await buildOrbotoMcpServer({ baseUrl: 'https://orboto.example.com', apiKey: 'orb_test', toolset: 'minimal' });
+        expect(zodCollectionBoundsInstalled()).toBe(true);
+        const result = await z.object({ ticketKeys: z.array(z.string()).max(100) }).safeParseAsync({ ticketKeys: Array.from({ length: 200_000 }, () => 0) });
+        expect(result.error?.issues).toEqual([expect.objectContaining({ code: 'too_big', maximum: 100 })]);
+        await server.close();
+    });
+    it('the guard refuses a zod instance without the bounds', () => {
+        class UnpatchedArray {
+        }
+        class UnpatchedRecord {
+        }
+        const unpatched = { ZodArray: UnpatchedArray, ZodRecord: UnpatchedRecord };
+        expect(() => assertZodCollectionBounds(unpatched)).toThrow(/zod collection bounds are not installed/);
+        expect(() => assertZodCollectionBounds()).not.toThrow();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orboto/mcp",
-  "version": "0.230.6",
+  "version": "0.230.8",
   "description": "Model Context Protocol server for orboto - exposes tickets, projects, milestones, time, docs, primer-facts, alerts and absences as MCP tools for Claude Desktop / Cursor / Copilot Chat / any MCP-aware AI client.",
   "license": "MIT",
   "type": "module",