@orboto/mcp 0.230.7 → 0.230.9

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';
@@ -73,6 +75,7 @@ import { checkToolConfig, makeCheckHandler, uncheckToolConfig, makeUncheckHandle
 import { listUsersToolConfig, makeListUsersHandler, getAuditLogToolConfig, makeGetAuditLogHandler, triggerBackupToolConfig, makeTriggerBackupHandler, } from './tools/admin-writes.js';
 import { freeBusyToolConfig, makeFreeBusyHandler } from './tools/free-busy.js';
 import { createFullBackupToolConfig, makeCreateFullBackupHandler, listBackupsToolConfig, makeListBackupsHandler, downloadBackupToolConfig, makeDownloadBackupHandler, } from './tools/backup.js';
+import { importNumberingToolConfig, makeImportNumberingHandler, importApplyToolConfig, makeImportApplyHandler, } from './tools/import-numbering.js';
 import { primerFactListToolConfig, makePrimerFactListHandler, primerFactAddToolConfig, makePrimerFactAddHandler, primerFactUpdateToolConfig, makePrimerFactUpdateHandler, primerFactSupersedeToolConfig, makePrimerFactSupersedeHandler, primerFactVerifyToolConfig, makePrimerFactVerifyHandler, primerFactDeleteToolConfig, makePrimerFactDeleteHandler, } from './tools/primer-facts.js';
 import { whoamiToolConfig, makeWhoamiHandler } from './tools/identity.js';
 import { claimToolConfig, makeClaimHandler, unclaimToolConfig, makeUnclaimHandler, } from './tools/claim.js';
@@ -146,6 +149,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 +172,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'
@@ -328,6 +333,8 @@ export async function buildOrbotoMcpServer(opts) {
     reg('orboto_create_full_backup', createFullBackupToolConfig, makeCreateFullBackupHandler(client));
     reg('orboto_list_backups', listBackupsToolConfig, makeListBackupsHandler(client));
     reg('orboto_download_backup', downloadBackupToolConfig, makeDownloadBackupHandler(client));
+    reg('orboto_import_numbering', importNumberingToolConfig, makeImportNumberingHandler(client));
+    reg('orboto_import_apply', importApplyToolConfig, makeImportApplyHandler(client));
     reg('orboto_primer_fact_list', primerFactListToolConfig, makePrimerFactListHandler(client));
     reg('orboto_primer_fact_add', primerFactAddToolConfig, makePrimerFactAddHandler(client));
     reg('orboto_primer_fact_update', primerFactUpdateToolConfig, makePrimerFactUpdateHandler(client));
@@ -381,8 +388,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.'),
@@ -95,6 +95,7 @@ export function makeGetTicketHandler(client) {
                 } : null,
                 childCount: children.length,
                 webUrl: full.webUrl ?? null,
+                ...(full.sourceSystem || full.sourceKey ? { source: { system: full.sourceSystem ?? null, key: full.sourceKey ?? null, id: full.sourceId ?? null } } : {}),
                 blockedBy: {
                     openCount: full.blockedByOpenCount ?? 0,
                     tickets: (full.blockedByOpen ?? []).map(dependencyEdge),
@@ -221,6 +222,7 @@ function formatTicket(ticket, inc, comments, commentTotal, ticketKey, checklists
             ? `Labels: ${ticket.labels.map((l) => l.name).join(', ')}`
             : null,
         ticket.branchName ? `Branch: ${ticket.branchName}` : null,
+        ticket.sourceSystem || ticket.sourceKey ? `Source: ${[ticket.sourceSystem, ticket.sourceKey].filter(Boolean).join(' ')}` : null,
         ticket.webUrl ? `Link: ${ticket.webUrl}` : null,
         formatDependencySummary('Blocked by', ticket.blockedByOpenCount, ticket.blockedByOpen),
         formatDependencySummary('Blocks', ticket.blocksOpenCount, ticket.blocksOpen),

package/dist/tools/import-numbering.js

@@ -0,0 +1,156 @@
+/**
+ * ORB-2676 - import numbering: the plan of kept and renumbered source tickets and the apply with its double merge confirmation.
+ */
+import { z } from 'zod';
+import { OrbotoApiError } from '../orboto-client.js';
+const MERGE_NOT_CONFIRMED = 'errors.admin_import.merge_not_confirmed';
+const NUMBERING_LIST_CAP = 30;
+const TITLE_CHARS = 50;
+const clip = (value, max) => (value.length > max ? `${value.slice(0, max - 3)}...` : value);
+const moreLine = (shown, total, what) => total > shown ? [`... ${total - shown} more ${what} not listed (${total} in all)`] : [];
+export function renumberedLine(r) {
+    const from = r.sourceKey ?? `#${r.sourceNumber}`;
+    const holder = r.reason === 'number_taken' && r.existingTicketKey
+        ? `; ${r.existingTicketKey}${r.existingTicketTitle ? ` "${clip(r.existingTicketTitle, TITLE_CHARS)}"` : ''}`
+        : '';
+    return `${from} -> ${r.ticketKey} (${r.reason}${holder})`;
+}
+function renumberedPayload(rows) {
+    return rows.map((r) => ({
+        from: r.sourceKey ?? `#${r.sourceNumber}`,
+        to: r.ticketKey,
+        reason: r.reason,
+        ...(r.existingTicketKey ? { existing: r.existingTicketKey } : {}),
+    }));
+}
+export function numberingResult(plan, token) {
+    const renumbered = Array.isArray(plan.renumbered) ? plan.renumbered : [];
+    const shown = renumbered.slice(0, NUMBERING_LIST_CAP);
+    const target = plan.projectKey ?? '(no key yet)';
+    const lines = [
+        `Import numbering for staged import ${token}: target ${target}${plan.sourceProjectKey ? `, source project ${plan.sourceProjectKey}` : ''}.`,
+        plan.merge
+            ? `MERGE: ${target} already has ${plan.existingTickets} tickets. Applying needs confirmMerge: true AND confirmProjectKey: "${target}" typed by the user (orboto_import_apply).`
+            : 'Not a merge: the target has no tickets yet.',
+        `Keep their source number: ${plan.preserved}. No source number (fresh numbers after the highest): ${plan.withoutSourceNumber}. Renumbered: ${renumbered.length}. Next free number: ${plan.nextTicketNumber}.`,
+        ...(plan.projectKeyIssue ? [`The source key ${plan.sourceProjectKey ?? ''} cannot become the project key: ${plan.projectKeyIssue === 'taken' ? 'another project holds it' : 'not 2-10 letters or digits'}.`] : []),
+    ];
+    if (renumbered.length > 0) {
+        lines.push('Renumbered tickets:', ...shown.map(renumberedLine), ...moreLine(shown.length, renumbered.length, 'renumbered tickets'));
+        if (renumbered.length > shown.length)
+            lines.push(`The complete list: \`orboto import numbering ${token}\` in the CLI, or GET /admin/import/jobs/${token}/numbering through orboto_api_call.`);
+    }
+    return {
+        content: [{ type: 'text', text: lines.join('\n') }],
+        structuredContent: {
+            projectKey: plan.projectKey,
+            sourceProjectKey: plan.sourceProjectKey,
+            projectKeyIssue: plan.projectKeyIssue,
+            merge: plan.merge,
+            existingTickets: plan.existingTickets,
+            preserved: plan.preserved,
+            withoutSourceNumber: plan.withoutSourceNumber,
+            nextTicketNumber: plan.nextTicketNumber,
+            renumberedTotal: renumbered.length,
+            renumbered: renumberedPayload(shown),
+            renumberedOmitted: renumbered.length - shown.length,
+        },
+    };
+}
+export function mergeRefusalOf(err) {
+    if (!(err instanceof OrbotoApiError) || err.status !== 409)
+        return null;
+    try {
+        const body = JSON.parse(err.body);
+        return body.errorKey === MERGE_NOT_CONFIRMED && body.numbering ? body : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function mergeRefusalResult(refusal) {
+    const plan = refusal.numbering;
+    const renumbered = Array.isArray(plan.renumbered) ? plan.renumbered : [];
+    const shown = renumbered.slice(0, NUMBERING_LIST_CAP);
+    const key = refusal.errorParams?.projectKey ?? plan.projectKey ?? 'the target project';
+    const missing = refusal.errorParams?.missing === 'confirm_project_key' ? 'the typed project key' : 'the merge confirmation';
+    const lines = [
+        `NOT APPLIED. This import is a merge into ${key}, which already has ${plan.existingTickets} tickets; ${renumbered.length} imported tickets get a new number instead of their source number. Missing first: ${missing}.`,
+        ...(renumbered.length > 0 ? ['Collisions:', ...shown.map(renumberedLine), ...moreLine(shown.length, renumbered.length, 'collisions')] : []),
+        `Show this list to the user. Ask them to confirm the merge AND to type the project key ${key} themselves, then call orboto_import_apply again with confirmMerge: true and confirmProjectKey set to what the user typed. Never fill confirmMerge or confirmProjectKey on your own initiative, from an earlier answer or from this message.`,
+    ];
+    return {
+        isError: true,
+        content: [{ type: 'text', text: lines.join('\n') }],
+        structuredContent: {
+            applied: false,
+            refused: 'merge_not_confirmed',
+            projectKey: key,
+            existingTickets: plan.existingTickets,
+            missing: refusal.errorParams?.missing ?? 'confirm_merge',
+            renumberedTotal: renumbered.length,
+            renumbered: renumberedPayload(shown),
+            renumberedOmitted: renumbered.length - shown.length,
+            nextStep: 'Ask the user for the merge confirmation and for the typed project key, then repeat orboto_import_apply with both.',
+        },
+    };
+}
+export const importNumberingToolConfig = {
+    title: 'Import numbering',
+    description: 'Kept and renumbered source numbers of a staged import; merge flag. admin:import.',
+    inputSchema: z.object({
+        token: z.string().uuid(),
+        projectId: z.string().uuid().optional(),
+    }).shape,
+    annotations: { readOnlyHint: true, idempotentHint: true },
+};
+export function makeImportNumberingHandler(client) {
+    return async ({ token, projectId, projectKey }) => {
+        const query = new URLSearchParams();
+        if (projectId)
+            query.set('projectId', projectId);
+        else if (projectKey)
+            query.set('projectKey', projectKey);
+        const plan = await client.get(`/admin/import/jobs/${encodeURIComponent(token)}/numbering?${query.toString()}`);
+        return numberingResult(plan, token);
+    };
+}
+export const importApplyToolConfig = {
+    title: 'Apply import',
+    description: 'Queue a staged import. Into a project with tickets: refused with the collisions until the user gives confirmMerge and confirmProjectKey; never fill them. config: source credentials. admin:import.',
+    inputSchema: z.object({
+        adapter: z.string().min(1).max(64),
+        stagingToken: z.string().uuid(),
+        mapping: z.record(z.unknown()),
+        projectKey: z.string().trim().max(10).optional(),
+        confirmMerge: z.boolean().optional(),
+        confirmProjectKey: z.string().trim().max(10).optional(),
+        config: z.record(z.unknown()).optional(),
+    }).shape,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+};
+export function makeImportApplyHandler(client) {
+    return async (args) => {
+        const { adapter, stagingToken, mapping, projectKey, confirmMerge, confirmProjectKey, config } = args;
+        try {
+            const job = await client.post(`/admin/import/${encodeURIComponent(adapter)}/apply-async`, {
+                stagingToken,
+                mapping,
+                ...(projectKey ? { projectKey } : {}),
+                ...(confirmMerge !== undefined ? { confirmMerge } : {}),
+                ...(confirmProjectKey ? { confirmProjectKey } : {}),
+                ...(config ? { config } : {}),
+            });
+            return {
+                content: [{ type: 'text', text: `Import ${job.status} (job ${job.jobId ?? 'none'}, token ${job.token}). Follow it with GET /admin/import/jobs/${job.token} through orboto_api_call; the finished result carries the numbering report.` }],
+                structuredContent: { applied: true, jobId: job.jobId, token: job.token, status: job.status },
+            };
+        }
+        catch (err) {
+            const refusal = mergeRefusalOf(err);
+            if (refusal)
+                return mergeRefusalResult(refusal);
+            throw err;
+        }
+    };
+}

package/dist/tools/import-numbering.test.js

@@ -0,0 +1,166 @@
+/**
+ * ORB-2676 - orboto_import_numbering and orboto_import_apply.
+ */
+import { describe, expect, it, vi } from 'vitest';
+import { OrbotoApiError } from '../orboto-client.js';
+import { applyResponseBudget, budgetFor, measureHalves } from '../response-budget.js';
+import { toolInToolset } from '../toolset.js';
+import { makeImportApplyHandler, makeImportNumberingHandler, mergeRefusalOf, renumberedLine, } from './import-numbering.js';
+const TOKEN = '3f2b6c1e-8a4d-4e5f-9b7a-1c2d3e4f5a6b';
+const PROJECT_ID = '9b7a1c2d-3e4f-4a6b-8c1d-2e3f4a5b6c7d';
+const textOf = (result) => result.content[0].text;
+function ticket(n, reason = 'number_taken') {
+    return {
+        sourceId: `10${n}`,
+        sourceKey: `PROJ-${n}`,
+        sourceNumber: n,
+        reason,
+        existingTicketKey: reason === 'number_taken' ? `KEY-${n}` : null,
+        existingTicketTitle: reason === 'number_taken' ? `Existing ticket number ${n}` : null,
+        ticketNumber: 100 + n,
+        ticketKey: `KEY-${100 + n}`,
+    };
+}
+function plan(overrides = {}) {
+    return {
+        projectKey: 'KEY',
+        sourceProjectKey: 'PROJ',
+        projectKeyIssue: null,
+        merge: true,
+        existingTickets: 12,
+        preserved: 40,
+        withoutSourceNumber: 2,
+        renumbered: [ticket(2), ticket(5, 'duplicate_source_number')],
+        nextTicketNumber: 160,
+        ...overrides,
+    };
+}
+function refusal(overrides = {}) {
+    const numbering = plan();
+    return {
+        error: 'This import merges into KEY',
+        errorKey: 'errors.admin_import.merge_not_confirmed',
+        errorParams: { projectKey: 'KEY', existingTickets: 12, renumbered: numbering.renumbered.length, missing: 'confirm_merge' },
+        numbering,
+        ...overrides,
+    };
+}
+const conflict = (body) => new OrbotoApiError(409, typeof body === 'string' ? body : JSON.stringify(body), 'https://orboto.example.com/admin/import/jira/apply-async');
+describe('orboto_import_numbering', () => {
+    it('reads the numbering route with the project id and prints counts plus one line per renumbered ticket', async () => {
+        const get = vi.fn().mockResolvedValue(plan());
+        const result = await makeImportNumberingHandler({ get })({ token: TOKEN, projectId: PROJECT_ID });
+        expect(get).toHaveBeenCalledWith(`/admin/import/jobs/${TOKEN}/numbering?projectId=${PROJECT_ID}`);
+        const text = textOf(result);
+        expect(text).toContain('MERGE: KEY already has 12 tickets');
+        expect(text).toContain('confirmProjectKey: "KEY" typed by the user');
+        expect(text).toContain('Keep their source number: 40. No source number (fresh numbers after the highest): 2. Renumbered: 2. Next free number: 160.');
+        expect(text).toContain('PROJ-2 -> KEY-102 (number_taken; KEY-2 "Existing ticket number 2")');
+        expect(text).toContain('PROJ-5 -> KEY-105 (duplicate_source_number)');
+        expect(result.structuredContent).toMatchObject({
+            merge: true, existingTickets: 12, preserved: 40, renumberedTotal: 2, renumberedOmitted: 0,
+            renumbered: [{ from: 'PROJ-2', to: 'KEY-102', reason: 'number_taken', existing: 'KEY-2' }, { from: 'PROJ-5', to: 'KEY-105', reason: 'duplicate_source_number' }],
+        });
+    });
+    it('sends the proposed key of a new project, says it is no merge and names an unusable source key', async () => {
+        const get = vi.fn().mockResolvedValue(plan({ merge: false, existingTickets: 0, renumbered: [], projectKey: 'NEWK', projectKeyIssue: 'taken' }));
+        const result = await makeImportNumberingHandler({ get })({ token: TOKEN, projectKey: 'NEWK' });
+        expect(get).toHaveBeenCalledWith(`/admin/import/jobs/${TOKEN}/numbering?projectKey=NEWK`);
+        expect(textOf(result)).toContain('Not a merge');
+        expect(textOf(result)).toContain('cannot become the project key: another project holds it');
+        expect(textOf(result)).not.toContain('Renumbered tickets');
+    });
+    it('falls back to a source number line for a ticket without a source key', () => {
+        expect(renumberedLine({ ...ticket(7), sourceKey: null })).toBe('#7 -> KEY-107 (number_taken; KEY-7 "Existing ticket number 7")');
+    });
+    it('lists the first 30 renumbered tickets and says explicitly how many it left out, inside the default budget', async () => {
+        const many = Array.from({ length: 2000 }, (_, i) => ticket(i + 1));
+        const get = vi.fn().mockResolvedValue(plan({ renumbered: many }));
+        const result = await makeImportNumberingHandler({ get })({ token: TOKEN });
+        expect(get).toHaveBeenCalledWith(`/admin/import/jobs/${TOKEN}/numbering?`);
+        expect(textOf(result)).toContain('... 1970 more renumbered tickets not listed (2000 in all)');
+        expect(textOf(result)).toContain(`orboto import numbering ${TOKEN}`);
+        expect(result.structuredContent).toMatchObject({ renumberedTotal: 2000, renumberedOmitted: 1970 });
+        expect(result.structuredContent.renumbered).toHaveLength(30);
+        const { textChars, structuredChars } = measureHalves(result);
+        expect(Math.max(textChars, structuredChars)).toBeLessThanOrEqual(budgetFor('orboto_import_numbering', {}));
+        const budgeted = applyResponseBudget('orboto_import_numbering', result, {});
+        expect(budgeted.truncatedChars).toBe(0);
+    });
+    it('is cut explicitly by the central budget when the answer is still too long', () => {
+        const long = Array.from({ length: 30 }, (_, i) => ({ ...ticket(i + 1), sourceKey: `PROJ-${'K'.repeat(400)}-${i}` }));
+        const get = vi.fn().mockResolvedValue(plan({ renumbered: long }));
+        return makeImportNumberingHandler({ get })({ token: TOKEN }).then((result) => {
+            const budgeted = applyResponseBudget('orboto_import_numbering', result, {});
+            expect(budgeted.responseChars).toBeLessThanOrEqual(budgetFor('orboto_import_numbering', {}) + 700);
+            expect(budgeted.handle).toBeTruthy();
+        });
+    });
+});
+describe('orboto_import_apply', () => {
+    const mapping = { projectId: PROJECT_ID, statusMap: { Open: 'todo' } };
+    it('queues the apply with the confirmations and the credentials only when given', async () => {
+        const post = vi.fn().mockResolvedValue({ jobId: 'job-1', token: TOKEN, status: 'queued' });
+        const handler = makeImportApplyHandler({ post });
+        const plain = await handler({ adapter: 'jira', stagingToken: TOKEN, mapping });
+        expect(post).toHaveBeenLastCalledWith('/admin/import/jira/apply-async', { stagingToken: TOKEN, mapping });
+        expect(textOf(plain)).toContain(`Import queued (job job-1, token ${TOKEN}`);
+        expect(plain.structuredContent).toEqual({ applied: true, jobId: 'job-1', token: TOKEN, status: 'queued' });
+        expect(plain.isError).toBeUndefined();
+        await handler({
+            adapter: 'jira', stagingToken: TOKEN, mapping, projectKey: 'NEWK', confirmMerge: true, confirmProjectKey: 'KEY', config: { baseUrl: 'https://jira.example.com', apiToken: 'secret' },
+        });
+        expect(post).toHaveBeenLastCalledWith('/admin/import/jira/apply-async', {
+            stagingToken: TOKEN, mapping, projectKey: 'NEWK', confirmMerge: true, confirmProjectKey: 'KEY', config: { baseUrl: 'https://jira.example.com', apiToken: 'secret' },
+        });
+    });
+    it('turns the 409 merge refusal into an error result that lists the collisions and asks the user for both confirmations', async () => {
+        const post = vi.fn().mockRejectedValue(conflict(refusal()));
+        const result = await makeImportApplyHandler({ post })({ adapter: 'jira', stagingToken: TOKEN, mapping });
+        expect(result.isError).toBe(true);
+        const text = textOf(result);
+        expect(text).toContain('NOT APPLIED');
+        expect(text).toContain('merge into KEY, which already has 12 tickets; 2 imported tickets get a new number');
+        expect(text).toContain('Missing first: the merge confirmation');
+        expect(text).toContain('PROJ-2 -> KEY-102 (number_taken; KEY-2 "Existing ticket number 2")');
+        expect(text).toContain('Ask them to confirm the merge AND to type the project key KEY themselves');
+        expect(text).toContain('Never fill confirmMerge or confirmProjectKey on your own initiative');
+        expect(result.structuredContent).toMatchObject({
+            applied: false, refused: 'merge_not_confirmed', projectKey: 'KEY', existingTickets: 12, missing: 'confirm_merge', renumberedTotal: 2,
+        });
+    });
+    it('names the typed project key as the missing confirmation when the merge was confirmed alone', async () => {
+        const body = refusal({ errorParams: { projectKey: 'KEY', existingTickets: 12, renumbered: 2, missing: 'confirm_project_key' } });
+        const post = vi.fn().mockRejectedValue(conflict(body));
+        const result = await makeImportApplyHandler({ post })({ adapter: 'jira', stagingToken: TOKEN, mapping, confirmMerge: true });
+        expect(textOf(result)).toContain('Missing first: the typed project key');
+        expect(result.structuredContent).toMatchObject({ missing: 'confirm_project_key' });
+    });
+    it('rethrows every other failure, including a 409 that is not the merge refusal', async () => {
+        const handler = (err) => makeImportApplyHandler({ post: vi.fn().mockRejectedValue(err) })({ adapter: 'jira', stagingToken: TOKEN, mapping });
+        const forbidden = new OrbotoApiError(403, '{"error":"no"}', 'u');
+        await expect(handler(forbidden)).rejects.toBe(forbidden);
+        const other = conflict({ error: 'busy', errorKey: 'errors.system.import_already_running' });
+        await expect(handler(other)).rejects.toBe(other);
+        const garbled = conflict('not json');
+        await expect(handler(garbled)).rejects.toBe(garbled);
+        const plain = new Error('network');
+        await expect(handler(plain)).rejects.toBe(plain);
+    });
+    it('recognises only the merge refusal with a numbering plan', () => {
+        expect(mergeRefusalOf(conflict(refusal()))?.errorParams?.projectKey).toBe('KEY');
+        expect(mergeRefusalOf(conflict({ errorKey: 'errors.admin_import.merge_not_confirmed' }))).toBeNull();
+        expect(mergeRefusalOf(new OrbotoApiError(400, JSON.stringify(refusal()), 'u'))).toBeNull();
+        expect(mergeRefusalOf(new Error('x'))).toBeNull();
+    });
+});
+describe('toolsets', () => {
+    it('keeps the two import tools out of the curated, minimal and channel sets', () => {
+        for (const name of ['orboto_import_numbering', 'orboto_import_apply']) {
+            expect(toolInToolset(name, 'full')).toBe(true);
+            expect(toolInToolset(name, 'curated')).toBe(false);
+            expect(toolInToolset(name, 'minimal')).toBe(false);
+            expect(toolInToolset(name, 'channel')).toBe(false);
+        }
+    });
+});

package/dist/tools/phase-b-tools.test.js

@@ -323,6 +323,29 @@ describe('orboto_get_ticket', () => {
         const sc = res.structuredContent;
         expect(sc.waitingForGitIngestion).toBe(true);
     });
+    it('ORB-2676: an imported ticket shows its source system and key; a native ticket shows no Source line', async () => {
+        const row = { id: 't1', projectId: 'p1', ticketKey: 'ACME-280', title: 'Imported', status: 'TODO', statusName: 'To Do', statusCategory: 'todo', type: 'task', priority: 'normal' };
+        stub([
+            { json: PROJ },
+            { json: { ...row, gitActivityCount: 0, parentTicketId: null } },
+            { json: { ...row, sourceSystem: 'jira', sourceKey: 'PROJ-280', sourceId: '10280' } },
+            NO_CHILDREN,
+            { json: [] },
+        ]);
+        const imported = await makeGetTicketHandler(client)({ ticketKey: 'ACME-280' });
+        expect(imported.content[0].text).toContain('Source: jira PROJ-280');
+        expect(imported.structuredContent.source).toEqual({ system: 'jira', key: 'PROJ-280', id: '10280' });
+        stub([
+            { json: PROJ },
+            { json: { ...row, gitActivityCount: 0, parentTicketId: null } },
+            { json: { ...row, sourceSystem: null, sourceKey: null, sourceId: null } },
+            NO_CHILDREN,
+            { json: [] },
+        ]);
+        const native = await makeGetTicketHandler(client)({ ticketKey: 'ACME-280' });
+        expect(native.content[0].text).not.toContain('Source:');
+        expect(native.structuredContent.source).toBeUndefined();
+    });
     it('include: ["checklistItems"] reads effectiveCompleted (not done) + surfaces linked-ticket suffix', async () => {
         stub([
             { json: PROJ },

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.7",
+  "version": "0.230.9",
   "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",