@modelprofile.com/mcp-crossharness 5.0.0 → 5.2.0

package/dist_ts/classes.mcptoolregistrar.js

@@ -0,0 +1,257 @@
+import * as plugins from './plugins.js';
+import { ConnectionRegistry } from './classes.connectionregistry.js';
+import { DispatchRegistry } from './classes.dispatchregistry.js';
+const harnessNameSchema = plugins.z.enum(['claudecode', 'opencode', 'codex']);
+/**
+ * Registers the Crossharness tool surface on an externally owned MCP server and
+ * owns only the resources used by those tools.
+ */
+export class CrossHarnessMcpToolRegistrar {
+    connections;
+    dispatches;
+    registeredTools = [];
+    registeredServer;
+    registered = false;
+    closeStarted = false;
+    closePromise;
+    resourceShutdownPromise;
+    constructor(connectionsArg = new ConnectionRegistry(), dispatchesArg = new DispatchRegistry()) {
+        this.connections = connectionsArg;
+        this.dispatches = dispatchesArg;
+    }
+    /** Register the tool surface before the externally owned MCP server connects. */
+    register(serverArg) {
+        if (this.closeStarted) {
+            throw new Error('Crossharness MCP tool registrar is closed');
+        }
+        if (this.registered) {
+            throw new Error('Crossharness MCP tools are already registered');
+        }
+        if (serverArg.isConnected()) {
+            throw new Error('Crossharness MCP tools must be registered before the MCP server connects');
+        }
+        const registeredTools = [];
+        try {
+            registeredTools.push(serverArg.registerTool('connect_harness', {
+                title: 'Connect to harness server',
+                description: 'Establish an explicit connection to an allowlisted harness web server. The exact origin must be listed in CROSSHARNESS_ALLOWED_SERVER_URLS. OpenCode uses http(s), Codex uses ws(s), and Claude Code is rejected because it exposes no URL-addressable session server. Returns a connectionId required by every connection-scoped operation; list_connections remains global.',
+                inputSchema: {
+                    harness: harnessNameSchema,
+                    serverUrl: plugins.z.string().max(2048).url().describe('Allowlisted harness server origin'),
+                    directory: plugins.z
+                        .string()
+                        .max(4096)
+                        .startsWith('/')
+                        .describe('Absolute project directory on the harness server'),
+                },
+            }, async (args, extra) => this.wrapToolCall(async () => {
+                const info = await this.connections.connect(args.harness, args.serverUrl, args.directory, extra.signal);
+                return this.describeConnection(info);
+            })));
+            registeredTools.push(serverArg.registerTool('disconnect_harness', {
+                title: 'Disconnect harness server',
+                description: 'Close and remove an established harness connection. In-flight requests fail; async dispatch records remain inspectable with check_reply.',
+                inputSchema: {
+                    connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+                },
+            }, async (args) => this.wrapToolCall(async () => this.describeConnection(await this.connections.disconnect(args.connectionId)))));
+            registeredTools.push(serverArg.registerTool('list_connections', {
+                title: 'List harness connections',
+                description: 'List explicit harness web-server connections established in this MCP process.',
+                inputSchema: {},
+            }, async () => this.wrapToolCall(async () => {
+                const connections = this.connections.list();
+                return connections.length > 0
+                    ? connections.map((connection) => this.describeConnection(connection)).join('\n\n')
+                    : 'No harness server connections established.';
+            })));
+            registeredTools.push(serverArg.registerTool('connection_status', {
+                title: 'Check harness connection',
+                description: 'Run the protocol health check for one explicit harness server connection.',
+                inputSchema: {
+                    connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+                },
+            }, async (args) => this.wrapToolCall(async () => {
+                const status = await this.connections.get(args.connectionId).getStatus();
+                return `${this.describeConnection(status)}\nhealthy: ${status.healthy ? 'yes' : 'no'}\ndetail: ${status.detail}`;
+            })));
+            registeredTools.push(serverArg.registerTool('list_chats', {
+                title: 'List harness chats',
+                description: 'List chats from the server and directory bound to an explicit connection. No local session stores are read.',
+                inputSchema: {
+                    connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+                    limit: plugins.z.number().int().min(1).max(100).optional(),
+                },
+            }, async (args) => this.wrapToolCall(async () => {
+                const chats = await this.connections.get(args.connectionId).listChats(args.limit ?? 10);
+                if (chats.length === 0)
+                    return 'No chats found for this connection.';
+                return [
+                    'harness\tchatId\tupdatedAt\tactivity\ttitle',
+                    ...chats.map((chat) => `${chat.harness}\t${chat.chatId}\t${chat.updatedAt}\t${chat.isActive ? 'active' : 'idle'}\t${chat.title.replace(/\s+/g, ' ').slice(0, 120)}`),
+                ].join('\n');
+            })));
+            registeredTools.push(serverArg.registerTool('read_chat', {
+                title: 'Read harness chat',
+                description: 'Read a chat through the harness web server bound to an explicit connection.',
+                inputSchema: {
+                    connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+                    chatId: plugins.z.string().min(1).max(1024),
+                    limit: plugins.z.number().int().min(1).max(500).optional(),
+                    maxChars: plugins.z.number().int().min(200).max(50000).optional(),
+                },
+            }, async (args) => this.wrapToolCall(async () => {
+                const transcript = await this.connections
+                    .get(args.connectionId)
+                    .readChat(args.chatId, args.limit ?? 20, args.maxChars ?? 2000);
+                const header = [
+                    `harness: ${transcript.harness}`,
+                    `chatId: ${transcript.chatId}`,
+                    `title: ${transcript.title}`,
+                    `directory: ${transcript.directory}`,
+                    transcript.totalMessages === undefined
+                        ? `messages: showing ${transcript.messages.length}; server total unavailable`
+                        : `messages: showing ${transcript.messages.length} of ${transcript.totalMessages}`,
+                ].join('\n');
+                const body = transcript.messages
+                    .map((message) => `-- [${message.role}]${message.timestamp ? ` ${message.timestamp}` : ''}\n${message.text}`)
+                    .join('\n');
+                return `${header}\n\n${body}`;
+            })));
+            registeredTools.push(serverArg.registerTool('send_message', {
+                title: 'Send message through harness server',
+                description: 'Send a message only through the harness web server bound to an explicit connection and wait for the reply. There is no CLI, process, local-store, discovery, or retry fallback.',
+                inputSchema: {
+                    connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+                    chatId: plugins.z.string().min(1).max(1024),
+                    message: plugins.z.string().min(1).max(1024 * 1024),
+                    timeoutSeconds: plugins.z.number().int().min(1).max(3600).optional(),
+                },
+            }, async (args, extra) => this.wrapToolCall(async () => {
+                const result = await this.connections
+                    .get(args.connectionId)
+                    .sendMessage(args.chatId, args.message, args.timeoutSeconds ?? 300, extra.signal);
+                return `${result.reply}\n\n[crossharness transport: ${result.via}]`;
+            })));
+            registeredTools.push(serverArg.registerTool('send_message_async', {
+                title: 'Send message through harness server asynchronously',
+                description: 'Start a server-only send and return a dispatchId immediately. Both this connectionId and the dispatchId are required by check_reply.',
+                inputSchema: {
+                    connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+                    chatId: plugins.z.string().min(1).max(1024),
+                    message: plugins.z.string().min(1).max(1024 * 1024),
+                    timeoutSeconds: plugins.z.number().int().min(1).max(3600).optional(),
+                },
+            }, async (args) => this.wrapToolCall(async () => {
+                const connection = this.connections.get(args.connectionId);
+                const record = this.dispatches.track(args.connectionId, connection.harness, args.chatId, () => connection.sendMessage(args.chatId, args.message, args.timeoutSeconds ?? 900));
+                return [
+                    `connectionId: ${record.connectionId}`,
+                    `dispatchId: ${record.dispatchId}`,
+                    `harness: ${record.harness}`,
+                    `chatId: ${record.chatId}`,
+                    `startedAt: ${record.startedAt}`,
+                ].join('\n');
+            })));
+            registeredTools.push(serverArg.registerTool('check_reply', {
+                title: 'Check async server send',
+                description: 'Check an asynchronous send. The connectionId must own the dispatch. Records remain inspectable after disconnect.',
+                inputSchema: {
+                    connectionId: plugins.z.string().max(128).describe('Connection id used for send_message_async'),
+                    dispatchId: plugins.z.string().max(128).describe('Dispatch id returned by send_message_async'),
+                    waitSeconds: plugins.z.number().int().min(0).max(60).optional(),
+                },
+            }, async (args, extra) => this.wrapToolCall(async () => {
+                const record = await this.dispatches.waitFor(args.connectionId, args.dispatchId, (args.waitSeconds ?? 0) * 1000, extra.signal);
+                if (!record)
+                    throw new Error('unknown dispatchId for this connectionId');
+                const header = [
+                    `connectionId: ${record.connectionId}`,
+                    `dispatchId: ${record.dispatchId}`,
+                    `status: ${record.status}`,
+                    `harness: ${record.harness}`,
+                    `chatId: ${record.chatId}`,
+                    `startedAt: ${record.startedAt}`,
+                    ...(record.completedAt ? [`completedAt: ${record.completedAt}`] : []),
+                ].join('\n');
+                if (record.status === 'working')
+                    return `${header}\n\nStill working.`;
+                if (record.status === 'failed')
+                    return `${header}\n\nError: ${record.error}`;
+                return `${header}\n\n${record.reply}\n\n[crossharness transport: ${record.via}]`;
+            })));
+        }
+        catch (errorArg) {
+            for (const registeredTool of registeredTools.reverse())
+                registeredTool.remove();
+            throw errorArg;
+        }
+        this.registeredTools = registeredTools;
+        this.registeredServer = serverArg;
+        this.registered = true;
+    }
+    /** Close the externally owned MCP server before closing this registrar. */
+    async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        if (this.registeredServer?.isConnected()) {
+            throw new Error('Crossharness MCP tool registrar cannot close while its MCP server is connected; close the shared MCP server first');
+        }
+        this.closeStarted = true;
+        this.removeRegisteredTools();
+        this.registeredServer = undefined;
+        this.closePromise = this.ensureResourceShutdown().finally(() => {
+            this.closePromise = undefined;
+        });
+        return this.closePromise;
+    }
+    removeRegisteredTools() {
+        for (const registeredTool of this.registeredTools.reverse())
+            registeredTool.remove();
+        this.registeredTools = [];
+    }
+    ensureResourceShutdown() {
+        if (this.resourceShutdownPromise)
+            return this.resourceShutdownPromise;
+        let shutdownPromise;
+        shutdownPromise = this.connections.closeAll().finally(() => {
+            this.dispatches.dispose();
+        }).catch((errorArg) => {
+            if (this.resourceShutdownPromise === shutdownPromise) {
+                this.resourceShutdownPromise = undefined;
+            }
+            throw errorArg;
+        });
+        this.resourceShutdownPromise = shutdownPromise;
+        return shutdownPromise;
+    }
+    describeConnection(infoArg) {
+        return [
+            `connectionId: ${infoArg.connectionId}`,
+            `harness: ${infoArg.harness}`,
+            `serverUrl: ${infoArg.serverUrl}`,
+            `directory: ${infoArg.directory}`,
+            `state: ${infoArg.state}`,
+            `connectedAt: ${infoArg.connectedAt}`,
+            ...(infoArg.serverVersion ? [`serverVersion: ${infoArg.serverVersion}`] : []),
+        ].join('\n');
+    }
+    async wrapToolCall(handlerArg) {
+        try {
+            const text = await handlerArg();
+            return { content: [{ type: 'text', text: text.slice(0, 100000) }] };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`.slice(0, 100000),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.mcptoolregistrar.js","sourceRoot":"","sources":["../ts/classes.mcptoolregistrar.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

@@ -1,5 +1,7 @@
 export * from './interfaces.js';
+export * from './classes.codexappserverclient.js';
 export * from './classes.connectionregistry.js';
 export * from './classes.dispatchregistry.js';
+export * from './classes.mcptoolregistrar.js';
 export * from './classes.mcpserver.js';
 export declare const runCli: () => Promise<void>;

package/dist_ts/index.js

@@ -1,9 +1,11 @@
 export * from './interfaces.js';
+export * from './classes.codexappserverclient.js';
 export * from './classes.connectionregistry.js';
 export * from './classes.dispatchregistry.js';
+export * from './classes.mcptoolregistrar.js';
 export * from './classes.mcpserver.js';
 import { CrossHarnessMcpServer } from './classes.mcpserver.js';
 export const runCli = async () => {
     await new CrossHarnessMcpServer().start();
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHdCQUF3QixDQUFDO0FBRXZDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRS9ELE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxLQUFLLElBQW1CLEVBQUU7SUFDOUMsTUFBTSxJQUFJLHFCQUFxQixFQUFFLENBQUMsS0FBSyxFQUFFLENBQUM7QUFDNUMsQ0FBQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUUvRCxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsS0FBSyxJQUFtQixFQUFFO0lBQzlDLE1BQU0sSUFBSSxxQkFBcUIsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDO0FBQzVDLENBQUMsQ0FBQyJ9

package/dist_ts/plugins.d.ts

@@ -5,6 +5,7 @@ import type { AddressInfo } from 'node:net';
 export { crypto, http, stream };
 export type { AddressInfo };
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { Client as McpClient } from '@modelcontextprotocol/sdk/client/index.js';
 import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
@@ -14,4 +15,5 @@ import type { RawData } from 'ws';
 import { z } from 'zod';
 export { InMemoryTransport, McpClient, McpServer, StdioServerTransport, WebSocketServer, WsWebSocket, z, };
 export type { RawData };
+export type { RegisteredTool };
 export type { Transport };

package/dist_ts/plugins.js

@@ -11,4 +11,4 @@ import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
 import { WebSocket as WsWebSocket, WebSocketServer } from 'ws';
 import { z } from 'zod';
 export { InMemoryTransport, McpClient, McpServer, StdioServerTransport, WebSocketServer, WsWebSocket, z, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsc0JBQXNCO0FBQ3RCLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBR3RDLE9BQU8sRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBR2hDLHNCQUFzQjtBQUN0QixPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFDcEUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDakYsT0FBTyxFQUFFLE1BQU0sSUFBSSxTQUFTLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNoRixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUUxRSxPQUFPLEVBQUUsU0FBUyxJQUFJLFdBQVcsRUFBRSxlQUFlLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFFL0QsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4QixPQUFPLEVBQ0wsaUJBQWlCLEVBQ2pCLFNBQVMsRUFDVCxTQUFTLEVBQ1Qsb0JBQW9CLEVBQ3BCLGVBQWUsRUFDZixXQUFXLEVBQ1gsQ0FBQyxHQUNGLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsc0JBQXNCO0FBQ3RCLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBR3RDLE9BQU8sRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBR2hDLHNCQUFzQjtBQUN0QixPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFFcEUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDakYsT0FBTyxFQUFFLE1BQU0sSUFBSSxTQUFTLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNoRixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUUxRSxPQUFPLEVBQUUsU0FBUyxJQUFJLFdBQVcsRUFBRSxlQUFlLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFFL0QsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4QixPQUFPLEVBQ0wsaUJBQWlCLEVBQ2pCLFNBQVMsRUFDVCxTQUFTLEVBQ1Qsb0JBQW9CLEVBQ3BCLGVBQWUsRUFDZixXQUFXLEVBQ1gsQ0FBQyxHQUNGLENBQUMifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/mcp-crossharness",
-  "version": "5.0.0",
+  "version": "5.2.0",
   "private": false,
   "description": "Connection-first MCP server for explicit OpenCode HTTP and Codex WebSocket session servers",
   "main": "dist_ts/index.js",
@@ -26,7 +26,7 @@
     "@git.zone/tsbuild": "^4.4.2",
     "@git.zone/tsrun": "^2.0.6",
     "@git.zone/tstest": "^4.0.0",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.1",
     "@types/ws": "^8.18.1"
   },
   "dependencies": {

package/readme.md

@@ -8,7 +8,7 @@ For reporting bugs, issues, or security vulnerabilities, please visit [community
 
 ## Transport Contract
 
-Crossharness only talks to explicitly connected harness web servers:
+Crossharness MCP tools only talk to explicitly connected harness web servers:
 
 | Harness | Server transport | Support |
 | --- | --- | --- |
@@ -140,13 +140,119 @@ Register the `mcp-crossharness` binary as a stdio MCP server in your client.
 
 ## Library API
 
+### Native Codex app-server client
+
+`CodexAppServerClient` exposes the underlying app-server protocol independently of the MCP
+chat tools. It accepts an explicit WebSocket endpoint or caller-owned JSONL stdio streams;
+it never discovers or spawns a server. The embedding application owns process lifecycle,
+session authorization, history projection, and human approval policy.
+
+```typescript
+import { CodexAppServerClient } from '@modelprofile.com/mcp-crossharness';
+
+const client = new CodexAppServerClient({
+  transport: { type: 'stdio', readable: child.stdout, writable: child.stdin },
+  clientInfo: { name: 'my-app', title: 'My App', version: '1.0.0' },
+  experimentalApi: true,
+  onNotification: ({ method, params }) => handleNotification(method, params),
+  onServerRequest: (request) => showApproval(request),
+  onClose: (error) => handleDisconnected(error),
+});
+await client.connect();
+const models = await client.request('model/list', {});
+// After a human decision, use the exact connection-scoped request ID:
+client.respond(requestId, { decision: 'accept' });
+client.close();
+```
+
+For WebSocket transport use `{ type: 'websocket', url: approvedServerUrl, token: bearerToken }`.
+The caller must authorize the destination before supplying credentials. The client follows no
+redirects and reads no credential environment variables. MCP tools retain their existing
+allowlist and credential policy.
+
+`request(method, params, timeoutMs?, signal?)` returns the protocol result as `unknown` for
+validation by the caller. It performs no retries. A `CodexAppServerRequestError` exposes
+`dispatched` and an optional server error `code`; a timeout or disconnect after dispatch
+does not prove a mutation failed. Never replay an uncertain `thread/start` or `turn/start`.
+The client handles initialize/initialized, response correlation, bounded framing, and close
+cleanup. The default inbound frame limit is 4 MiB; `maxMessageBytes` accepts 1 KiB–64 MiB.
+Outgoing buffers are capped at 4 MiB and pending requests at 256 in each direction.
+
+Server request handlers return immediately so notifications continue during human input.
+Each request carries an `AbortSignal`, aborted when it is answered, resolved by the server,
+or disconnected. `respond(id, result)` and `rejectRequest(id, code, message)` return false
+for an expired ID. Unhandled server requests receive method-not-supported; this low-level
+client never grants or automatically declines a permission. `close()` ends the supplied
+stdio streams but never kills a subprocess. The existing MCP Codex adapter delegates to
+this client and retains its conservative automatic rejection policy.
+
+### Composable tool registration
+
+`CrossHarnessMcpToolRegistrar` registers the same nine Crossharness tools used by the standalone
+server on an MCP SDK 1.30 `McpServer` owned by an embedding application:
+
 ```typescript
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import {
   ConnectionRegistry,
-  DispatchRegistry,
-  CrossHarnessMcpServer,
+  CrossHarnessMcpToolRegistrar,
 } from '@modelprofile.com/mcp-crossharness';
 
+const connections = new ConnectionRegistry({
+  allowedServerUrls: ['http://127.0.0.1:4096/'],
+  openCodeCredentials: {
+    serverUrl: 'http://127.0.0.1:4096/',
+    username: 'opencode',
+    password: controllerOwnedPassword,
+  },
+});
+const crossHarnessTools = new CrossHarnessMcpToolRegistrar(connections);
+const sharedServer = new McpServer({ name: 'controller', version: '1.0.0' });
+
+crossHarnessTools.register(sharedServer);
+await sharedServer.connect(hostOwnedTransport);
+
+// During host shutdown, close the shared server before its Crossharness registrar.
+await sharedServer.close();
+await crossHarnessTools.close();
+```
+
+The registrar takes lifecycle ownership of injected `ConnectionRegistry` and `DispatchRegistry`
+instances. Call `register()` before connecting the shared server. A successful registrar can
+register only once.
+
+Composition supports an ordinary high-level `McpServer` tool surface, including host tools added
+with `McpServer.registerTool()`. A duplicate high-level tool name throws and transactionally removes
+the Crossharness tools added by that attempt without replacing the host's tool.
+
+Do not preinstall custom low-level `tools/list` or `tools/call` handlers with
+`sharedServer.server.setRequestHandler()`. SDK 1.30 adds the first high-level tool to its internal
+map before discovering that low-level handler conflict and throwing, without returning a
+`RegisteredTool` handle. The registrar cannot transactionally roll back that SDK mutation. Use the
+ordinary high-level `McpServer.registerTool()` surface or a separate `McpServer` instead.
+
+`close()` removes the registrar's tool registrations, closes every owned connection, and disposes
+its dispatch registry. If the registered server is still connected, `close()` fails before
+removing tools or mutating either registry. Close the shared server first, then call registrar
+`close()`; failed connection cleanup remains retryable by calling it again. The registrar never
+connects or closes the shared `McpServer`, never owns its transport, and installs no stdin,
+process-signal, or shared-server close listeners.
+
+`CrossHarnessMcpServer` is the standalone stdio lifecycle wrapper. It creates this exact registrar,
+keeps the existing one-shot `start()` contract, and owns only its own MCP server, transport, and
+stdin close handling in addition to delegating tool-resource cleanup to the registrar. It closes
+the server before the registrar, retains the same server and transport when transport close fails,
+and retries them on the next `close()`. Concurrent transport and registrar cleanup failures are
+reported together as an `AggregateError`.
+
+### Direct registry use
+
+The registries remain public for applications that need the connection API without MCP tool
+registration:
+
+```typescript
+import { ConnectionRegistry } from '@modelprofile.com/mcp-crossharness';
+
 const connections = new ConnectionRegistry({
   allowedServerUrls: ['http://127.0.0.1:4096/'],
   openCodeCredentials: {

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/mcp-crossharness',
-  version: '5.0.0',
+  version: '5.2.0',
   description: 'Connection-first MCP server for explicit OpenCode HTTP and Codex WebSocket session servers'
 }