@nudge-ui/mcp 0.2.1 → 0.2.3

package/dist/discovery.d.ts

@@ -1,13 +1,14 @@
+import type { AgentActivity } from "./internal/agent-protocol.js";
 import type { AgentPromptRequest, AgentStatusSnapshot, AgentStatusUpdate, CanvasCommandResult } from "./internal/agent-protocol.js";
 import type { CanvasCommandInput } from "./bridge.js";
-import { type ProjectSession } from "./project.js";
+import { type ProjectSession, type StoredProjectSession } from "./project.js";
 export interface DiscoveredProjectSession extends ProjectSession {
     readonly matchesWorkspace: boolean;
     readonly matchesApplication: boolean;
     readonly claimed: boolean;
     readonly status: Pick<AgentStatusSnapshot, "connection" | "listenerActive" | "paired">;
 }
-export declare function discoverProjectSessions(applicationRoot: string, registryRoot?: string): Promise<DiscoveredProjectSession[]>;
+export declare function discoverProjectSessions(applicationRoot: string | undefined, registryRoot?: string): Promise<DiscoveredProjectSession[]>;
 /** Routes MCP tools to a live project in the adapter's exact worktree. */
 export declare class DiscoveredProjectRouter {
     readonly workspaceRoot: string;
@@ -16,14 +17,32 @@ export declare class DiscoveredProjectRouter {
     readonly agentId: string;
     private client;
     private releaseGeneration;
+    private connectionQueue;
     private constructor();
+    get selectedSessionId(): string | undefined;
+    static forSession(session: StoredProjectSession, registryRoot: string): DiscoveredProjectRouter;
     static create(workspaceRoot: string, registryRoot?: string): Promise<DiscoveredProjectRouter>;
     listSessions(): Promise<DiscoveredProjectSession[]>;
     private connectToSession;
-    waitForPrompt(signal?: AbortSignal, sessionId?: string): Promise<AgentPromptRequest>;
+    private selectSession;
+    waitForPrompt(signal?: AbortSignal, sessionId?: string, agentClientName?: string): Promise<AgentPromptRequest>;
     getStatus(): Promise<AgentStatusSnapshot>;
+    reportActivity(activity: AgentActivity): Promise<void>;
     updateRequestStatus(update: AgentStatusUpdate): Promise<AgentStatusSnapshot>;
     dispatchCanvasCommand(command: CanvasCommandInput): Promise<CanvasCommandResult>;
     release(): Promise<void>;
     close(): Promise<void>;
 }
+/** Returns diagnostic counts, scope, and public paths without exposing registry credentials. */
+export declare function diagnoseProjectSessions(applicationRoot?: string, registryRoot?: string): Promise<{
+    registryRoot: string;
+    workspaceRoot: string | undefined;
+    applicationRoot: string | undefined;
+    descriptorCount: number;
+    invalidCount: number;
+    incompatibleCount: number;
+    reachableCount: number;
+    matchingReachableCount: number;
+    matchingUnreachableCount: number;
+    guidance: string[];
+}>;

package/dist/discovery.js

@@ -1,8 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { realpath } from "node:fs/promises";
-import { resolve } from "node:path";
+import { isAbsolute, resolve } from "node:path";
 import { ProjectSessionClient } from "./projectSessionClient.js";
-import { readLiveProjectSessions } from "./sessionRegistry.js";
+import { inspectProjectSessions, readLiveProjectSessions } from "./sessionRegistry.js";
 import { matchesApplication, selectProjectSession } from "./sessionSelection.js";
 import { defaultSessionRegistryRoot, resolveWorkspaceRoot, } from "./project.js";
 function publicSession(session) {
@@ -10,15 +10,17 @@ function publicSession(session) {
     return visible;
 }
 export async function discoverProjectSessions(applicationRoot, registryRoot = defaultSessionRegistryRoot()) {
-    const canonicalApplication = await realpath(resolve(applicationRoot));
-    const canonicalWorkspace = await resolveWorkspaceRoot(canonicalApplication);
+    const canonicalApplication = applicationRoot === undefined
+        ? undefined
+        : await realpath(requireAbsoluteWorkspaceRoot(applicationRoot));
+    const canonicalWorkspace = canonicalApplication === undefined ? undefined : await resolveWorkspaceRoot(canonicalApplication);
     const live = await readLiveProjectSessions(resolve(registryRoot));
     return live.map(({ descriptor, health }) => {
         const matchesWorkspace = descriptor.workspaceRoot === canonicalWorkspace;
         return {
             ...publicSession(descriptor),
             matchesWorkspace,
-            matchesApplication: matchesApplication(descriptor, {
+            matchesApplication: canonicalWorkspace !== undefined && canonicalApplication !== undefined && matchesApplication(descriptor, {
                 workspaceRoot: canonicalWorkspace,
                 applicationRoot: canonicalApplication,
             }),
@@ -39,20 +41,34 @@ export class DiscoveredProjectRouter {
     agentId;
     client = null;
     releaseGeneration = 0;
+    connectionQueue = Promise.resolve();
     constructor(workspaceRoot, applicationRoot, registryRoot, agentId) {
         this.workspaceRoot = workspaceRoot;
         this.applicationRoot = applicationRoot;
         this.registryRoot = registryRoot;
         this.agentId = agentId;
     }
+    get selectedSessionId() {
+        return this.client?.descriptor.sessionId;
+    }
+    static forSession(session, registryRoot) {
+        const router = new DiscoveredProjectRouter(session.workspaceRoot, session.appRoot, registryRoot, randomUUID());
+        router.client = new ProjectSessionClient(session, router.agentId);
+        return router;
+    }
     static async create(workspaceRoot, registryRoot = defaultSessionRegistryRoot()) {
-        const applicationRoot = await realpath(resolve(workspaceRoot));
+        const applicationRoot = await realpath(requireAbsoluteWorkspaceRoot(workspaceRoot));
         return new DiscoveredProjectRouter(await resolveWorkspaceRoot(applicationRoot), applicationRoot, resolve(registryRoot), randomUUID());
     }
     async listSessions() {
         return await discoverProjectSessions(this.applicationRoot, this.registryRoot);
     }
-    async connectToSession(sessionId) {
+    connectToSession(sessionId) {
+        const connection = this.connectionQueue.then(() => this.selectSession(sessionId));
+        this.connectionQueue = connection.then(() => undefined, () => undefined);
+        return connection;
+    }
+    async selectSession(sessionId) {
         const live = await readLiveProjectSessions(this.registryRoot);
         const selected = selectProjectSession(live.map(({ descriptor }) => descriptor), {
             workspaceRoot: this.workspaceRoot,
@@ -66,7 +82,7 @@ export class DiscoveredProjectRouter {
         this.client = new ProjectSessionClient(selected, this.agentId);
         return this.client;
     }
-    async waitForPrompt(signal, sessionId) {
+    async waitForPrompt(signal, sessionId, agentClientName) {
         const releaseGeneration = this.releaseGeneration;
         const client = await this.connectToSession(sessionId);
         if (releaseGeneration !== this.releaseGeneration) {
@@ -77,7 +93,7 @@ export class DiscoveredProjectRouter {
             throw new Error("The Nudge project session was released.");
         }
         try {
-            return await client.waitForPrompt(signal);
+            return await client.waitForPrompt(signal, agentClientName);
         }
         catch (error) {
             if (signal?.aborted || sessionId || releaseGeneration !== this.releaseGeneration)
@@ -85,13 +101,17 @@ export class DiscoveredProjectRouter {
             const replacement = await this.connectToSession();
             if (replacement === client)
                 throw error;
-            return await replacement.waitForPrompt(signal);
+            return await replacement.waitForPrompt(signal, agentClientName);
         }
     }
     async getStatus() {
         const client = await this.connectToSession();
         return await client.getStatus();
     }
+    async reportActivity(activity) {
+        const client = await this.connectToSession();
+        await client.reportActivity(activity);
+    }
     async updateRequestStatus(update) {
         const client = await this.connectToSession();
         return await client.updateRequestStatus(update);
@@ -102,6 +122,7 @@ export class DiscoveredProjectRouter {
     }
     async release() {
         this.releaseGeneration += 1;
+        await this.connectionQueue;
         const client = this.client;
         this.client = null;
         await client?.close();
@@ -110,3 +131,34 @@ export class DiscoveredProjectRouter {
         await this.release();
     }
 }
+/** Returns diagnostic counts, scope, and public paths without exposing registry credentials. */
+export async function diagnoseProjectSessions(applicationRoot, registryRoot = defaultSessionRegistryRoot()) {
+    const resolvedRegistryRoot = resolve(registryRoot);
+    const app = applicationRoot === undefined
+        ? undefined
+        : await realpath(requireAbsoluteWorkspaceRoot(applicationRoot));
+    const workspace = app === undefined ? undefined : await resolveWorkspaceRoot(app);
+    const inspection = await inspectProjectSessions(resolvedRegistryRoot);
+    const matching = (session) => app === undefined || (session.workspaceRoot === workspace && (app === workspace || session.appRoot === app));
+    return {
+        registryRoot: resolvedRegistryRoot,
+        workspaceRoot: workspace,
+        applicationRoot: app,
+        descriptorCount: inspection.descriptorCount,
+        invalidCount: inspection.invalidCount,
+        incompatibleCount: inspection.incompatibleCount,
+        reachableCount: inspection.live.length,
+        matchingReachableCount: inspection.live.filter(({ descriptor }) => matching(descriptor)).length,
+        matchingUnreachableCount: inspection.unreachable.filter(matching).length,
+        guidance: [
+            ...(inspection.invalidCount > 0 ? ["Some session descriptors or authenticated health responses are invalid. Check the adapter and project bridge versions, descriptor permissions, and bridge logs."] : []),
+            ...(inspection.unreachable.some(matching) ? ["Matching descriptors exist but their loopback endpoints are unreachable. The server may have stopped or local networking may be blocked. Retry outside the agent command sandbox; do not treat this as proof that no bridge registered."] : []),
+            ...(inspection.incompatibleCount > 0 ? ["Some registrations use an incompatible protocol. Upgrade the reusable adapter and the project's @nudge-ui/mcp dependency, then restart the development server and agent host."] : []),
+        ],
+    };
+}
+function requireAbsoluteWorkspaceRoot(workspaceRoot) {
+    if (!isAbsolute(workspaceRoot))
+        throw new TypeError("workspaceRoot must be an absolute path.");
+    return workspaceRoot;
+}

package/dist/internal/agent-protocol.d.ts

@@ -177,6 +177,8 @@ export interface AgentStatusSnapshot {
     readonly projectId: string;
     readonly connection: AgentConnectionState;
     readonly listenerActive: boolean;
+    /** MCP client name supplied during initialization; absent for older adapters. */
+    readonly agentClientName?: string;
     readonly paired: boolean;
     /** The last paired page, retained only for this process lifetime. */
     readonly pageUrl?: string | null;
@@ -186,7 +188,7 @@ export interface AgentStatusSnapshot {
         readonly error?: string;
     }) | null;
 }
-export type BridgeEventType = "status" | "canvas-command" | "connected" | "disconnected";
+export type BridgeEventType = "activity" | "status" | "canvas-command" | "connected" | "disconnected";
 export interface BridgeStatusEvent {
     readonly type: "status";
     readonly status: AgentStatusSnapshot;
@@ -203,8 +205,23 @@ export interface BridgeCanvasCommandEvent {
     readonly type: "canvas-command";
     readonly command: CanvasCommand;
 }
+/** Temporary attribution for one file operation in an authoritative request. */
+export interface AgentActivity {
+    readonly requestId: string;
+    /** Workspace-relative source path. */
+    readonly file: string;
+    readonly operation: "read" | "edit";
+    readonly line?: number;
+    readonly endLine?: number;
+    readonly componentId?: string;
+}
+export declare function isAgentActivity(value: unknown): value is AgentActivity;
+export interface BridgeActivityEvent {
+    readonly type: "activity";
+    readonly activity: AgentActivity;
+}
 /** Payload delivered to a browser SSE connection. */
-export type BridgeEvent = BridgeStatusEvent | BridgeConnectedEvent | BridgeDisconnectedEvent | BridgeCanvasCommandEvent;
+export type BridgeEvent = BridgeActivityEvent | BridgeStatusEvent | BridgeConnectedEvent | BridgeDisconnectedEvent | BridgeCanvasCommandEvent;
 export interface BridgeEnvelope {
     readonly protocolVersion: AgentProtocolVersion;
     readonly projectId: string;

package/dist/internal/agent-protocol.js

@@ -61,6 +61,19 @@ export const CANVAS_COMMAND_TYPES = [
     "fit-all",
     "remove-group",
 ];
+export function isAgentActivity(value) {
+    if (!isRecord(value) || !hasOnlyKeys(value, ["requestId", "file", "operation", "line", "endLine", "componentId"]))
+        return false;
+    const line = (value) => Number.isSafeInteger(value) && Number(value) > 0 && Number(value) <= 10_000_000;
+    return nonEmptyString(value.requestId, AGENT_PROTOCOL_LIMITS.requestId)
+        && nonEmptyString(value.file, AGENT_PROTOCOL_LIMITS.workspaceRoot)
+        && !/^(?:[\\/]|[a-z]:)/i.test(value.file) && !/[\\\u0000-\u001f]/.test(value.file)
+        && !value.file.split("/").some((part, index, parts) => !part || part === "." || (part === ".." && parts.slice(0, index).some((previous) => previous !== "..")))
+        && (value.operation === "read" || value.operation === "edit")
+        && (value.line === undefined || line(value.line))
+        && (value.endLine === undefined || (line(value.endLine) && line(value.line) && Number(value.endLine) >= Number(value.line)))
+        && (value.componentId === undefined || nonEmptyString(value.componentId, 512));
+}
 const ORIGIN_PROTOCOLS = new Set(["http:", "https:"]);
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/projectSessionClient.d.ts

@@ -1,3 +1,4 @@
+import type { AgentActivity } from "./internal/agent-protocol.js";
 import type { AgentPromptRequest, AgentStatusSnapshot, AgentStatusUpdate, CanvasCommandResult } from "./internal/agent-protocol.js";
 import type { CanvasCommandInput } from "./bridge.js";
 import type { StoredProjectSession } from "./project.js";
@@ -7,6 +8,11 @@ export interface SessionHealth {
     readonly claimed: boolean;
     readonly status: AgentStatusSnapshot;
 }
+/** Represents an HTTP response from a project bridge that could be classified. */
+export declare class ProjectSessionResponseError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
 export declare function readSessionHealth(session: StoredProjectSession, timeoutMs?: number): Promise<SessionHealth>;
 /** Owns one project's claim, heartbeat, and authenticated control requests. */
 export declare class ProjectSessionClient {
@@ -20,8 +26,9 @@ export declare class ProjectSessionClient {
     private send;
     private acquireClaim;
     private claim;
-    waitForPrompt(signal?: AbortSignal): Promise<AgentPromptRequest>;
+    waitForPrompt(signal?: AbortSignal, agentClientName?: string): Promise<AgentPromptRequest>;
     getStatus(): Promise<AgentStatusSnapshot>;
+    reportActivity(activity: AgentActivity): Promise<void>;
     updateRequestStatus(update: AgentStatusUpdate): Promise<AgentStatusSnapshot>;
     dispatchCanvasCommand(input: CanvasCommandInput): Promise<CanvasCommandResult>;
     close(): Promise<void>;

package/dist/projectSessionClient.js

@@ -2,6 +2,15 @@ import { randomUUID } from "node:crypto";
 import { AGENT_CONTROL_ENDPOINTS } from "./protocol.js";
 const CONTROL_TIMEOUT_MS = 5_000;
 const CANVAS_TIMEOUT_MS = 65_000;
+/** Represents an HTTP response from a project bridge that could be classified. */
+export class ProjectSessionResponseError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = "ProjectSessionResponseError";
+        this.status = status;
+    }
+}
 async function requestJson(session, path, init = {}, { signal, timeoutMs = CONTROL_TIMEOUT_MS } = {}) {
     const response = await fetch(`${session.endpoint}${path}`, {
         ...init,
@@ -14,8 +23,9 @@ async function requestJson(session, path, init = {}, { signal, timeoutMs = CONTR
         },
     });
     const body = await response.json().catch(() => undefined);
-    if (!response.ok)
-        throw new Error(body?.error?.message ?? `Nudge project bridge returned ${response.status}.`);
+    if (!response.ok) {
+        throw new ProjectSessionResponseError(response.status, body?.error?.message ?? `Nudge project bridge returned ${response.status}.`);
+    }
     return body;
 }
 export async function readSessionHealth(session, timeoutMs = CONTROL_TIMEOUT_MS) {
@@ -62,14 +72,18 @@ export class ProjectSessionClient {
             this.claimPromise = null;
         }
     }
-    async waitForPrompt(signal) {
+    async waitForPrompt(signal, agentClientName) {
         await this.claim();
-        return await this.send(AGENT_CONTROL_ENDPOINTS.listen, {}, { signal, timeoutMs: null });
+        return await this.send(AGENT_CONTROL_ENDPOINTS.listen, { agentClientName }, { signal, timeoutMs: null });
     }
     async getStatus() {
         const health = await readSessionHealth(this.descriptor);
         return health.status;
     }
+    async reportActivity(activity) {
+        await this.claim();
+        await this.send(AGENT_CONTROL_ENDPOINTS.activity, { activity });
+    }
     async updateRequestStatus(update) {
         await this.claim();
         return await this.send(AGENT_CONTROL_ENDPOINTS.reportStatus, { update });

package/dist/protocol.d.ts

@@ -5,12 +5,13 @@
  * subpath keeps transport names discoverable for Node consumers while
  * preserving one protocol vocabulary for browser and agent adapters.
  */
-export { AGENT_PROTOCOL_LIMITS, AGENT_PROTOCOL_VERSION, CANVAS_COMMAND_TYPES, canonicalOrigin, defaultBridgePort, isAgentPromptRequest, isAgentSketchAttachment, isAgentSketchCaptureMetadata, isAgentSketchMetadata, isAgentStatusUpdate, isAllowedOrigin, isCanvasCommand, isCanvasGroup, isCanvasState, isCanonicalOrigin, isProjectIdentity, isSameOriginRoute, protocolError, validateSketchAttachments, validateRoutes, } from "./internal/agent-protocol.js";
-export type { AgentConnectionState, AgentProjectIdentity, AgentPromptRequest, AgentDeliveredPrompt, AgentSketchAttachment, AgentSketchCaptureMetadata, AgentSketchMetadata, AgentRequestOutcome, AgentRequestStatus, AgentRoute, AgentStatusSnapshot, AgentStatusUpdate, BridgeCanvasCommandEvent, BridgeConnectedEvent, BridgeDisconnectedEvent, BridgeEnvelope, BridgeEvent, BridgeEventType, BridgeStatusEvent, CanvasCommand, CanvasCommandAcknowledgement, CanvasCommandError, CanvasCommandResult, CanvasGroup, CanvasGroupOwner, CanvasState, FitCanvasCommand, FocusCanvasGroupCommand, PairingRequest, PairingResponse, PresentRoutesCommand, PromptDispatchRequest, PromptDispatchResponse, ReadCanvasStateCommand, RemoveCanvasGroupCommand, StatusEventRequest, } from "./internal/agent-protocol.js";
+export { AGENT_PROTOCOL_LIMITS, AGENT_PROTOCOL_VERSION, CANVAS_COMMAND_TYPES, canonicalOrigin, defaultBridgePort, isAgentPromptRequest, isAgentSketchAttachment, isAgentSketchCaptureMetadata, isAgentSketchMetadata, isAgentStatusUpdate, isAgentActivity, isAllowedOrigin, isCanvasCommand, isCanvasGroup, isCanvasState, isCanonicalOrigin, isProjectIdentity, isSameOriginRoute, protocolError, validateSketchAttachments, validateRoutes, } from "./internal/agent-protocol.js";
+export type { AgentActivity, BridgeActivityEvent, AgentConnectionState, AgentProjectIdentity, AgentPromptRequest, AgentDeliveredPrompt, AgentSketchAttachment, AgentSketchCaptureMetadata, AgentSketchMetadata, AgentRequestOutcome, AgentRequestStatus, AgentRoute, AgentStatusSnapshot, AgentStatusUpdate, BridgeCanvasCommandEvent, BridgeConnectedEvent, BridgeDisconnectedEvent, BridgeEnvelope, BridgeEvent, BridgeEventType, BridgeStatusEvent, CanvasCommand, CanvasCommandAcknowledgement, CanvasCommandError, CanvasCommandResult, CanvasGroup, CanvasGroupOwner, CanvasState, FitCanvasCommand, FocusCanvasGroupCommand, PairingRequest, PairingResponse, PresentRoutesCommand, PromptDispatchRequest, PromptDispatchResponse, ReadCanvasStateCommand, RemoveCanvasGroupCommand, StatusEventRequest, } from "./internal/agent-protocol.js";
 /** Stable endpoint names used by the loopback browser bridge. */
 export declare const BRIDGE_ENDPOINTS: {
     readonly health: "/health";
     readonly pair: "/pair";
+    readonly takeover: "/takeover";
     readonly events: "/events";
     readonly prompt: "/prompt";
     readonly status: "/status";
@@ -26,6 +27,7 @@ export declare const AGENT_CONTROL_ENDPOINTS: {
     readonly listen: "/__nudge/agent/listen";
     readonly status: "/__nudge/agent/status";
     readonly reportStatus: "/__nudge/agent/report-status";
+    readonly activity: "/__nudge/agent/activity";
     readonly canvas: "/__nudge/agent/canvas";
 };
 export type BridgeEndpoint = (typeof BRIDGE_ENDPOINTS)[keyof typeof BRIDGE_ENDPOINTS];

package/dist/protocol.js

@@ -5,11 +5,12 @@
  * subpath keeps transport names discoverable for Node consumers while
  * preserving one protocol vocabulary for browser and agent adapters.
  */
-export { AGENT_PROTOCOL_LIMITS, AGENT_PROTOCOL_VERSION, CANVAS_COMMAND_TYPES, canonicalOrigin, defaultBridgePort, isAgentPromptRequest, isAgentSketchAttachment, isAgentSketchCaptureMetadata, isAgentSketchMetadata, isAgentStatusUpdate, isAllowedOrigin, isCanvasCommand, isCanvasGroup, isCanvasState, isCanonicalOrigin, isProjectIdentity, isSameOriginRoute, protocolError, validateSketchAttachments, validateRoutes, } from "./internal/agent-protocol.js";
+export { AGENT_PROTOCOL_LIMITS, AGENT_PROTOCOL_VERSION, CANVAS_COMMAND_TYPES, canonicalOrigin, defaultBridgePort, isAgentPromptRequest, isAgentSketchAttachment, isAgentSketchCaptureMetadata, isAgentSketchMetadata, isAgentStatusUpdate, isAgentActivity, isAllowedOrigin, isCanvasCommand, isCanvasGroup, isCanvasState, isCanonicalOrigin, isProjectIdentity, isSameOriginRoute, protocolError, validateSketchAttachments, validateRoutes, } from "./internal/agent-protocol.js";
 /** Stable endpoint names used by the loopback browser bridge. */
 export const BRIDGE_ENDPOINTS = {
     health: "/health",
     pair: "/pair",
+    takeover: "/takeover",
     events: "/events",
     prompt: "/prompt",
     status: "/status",
@@ -25,5 +26,6 @@ export const AGENT_CONTROL_ENDPOINTS = {
     listen: "/__nudge/agent/listen",
     status: "/__nudge/agent/status",
     reportStatus: "/__nudge/agent/report-status",
+    activity: "/__nudge/agent/activity",
     canvas: "/__nudge/agent/canvas",
 };

package/dist/server.d.ts

@@ -2,6 +2,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { AgentProjectIdentity } from "./internal/agent-protocol.js";
 import { type BrowserBridge, type BrowserBridgeOptions, type BridgeAddress } from "./bridge.js";
+import { AdapterRouting } from "./adapterRouting.js";
 import { DiscoveredProjectRouter } from "./discovery.js";
 export declare const MCP_SERVER_NAME = "nudge-ui";
 export declare const MCP_SERVER_VERSION: string;
@@ -29,13 +30,13 @@ export interface AgentCompanion {
 export declare function createAgentCompanion(options: AgentCompanionOptions): AgentCompanion;
 export interface DiscoveredAgentAdapter {
     readonly mcpServer: McpServer;
-    readonly router: DiscoveredProjectRouter;
+    readonly router: DiscoveredProjectRouter | AdapterRouting;
     start(transport?: Transport): Promise<void>;
     close(): Promise<void>;
 }
 /** Creates a stdio MCP adapter that discovers project-owned bridges. */
 export declare function createDiscoveredAgentAdapter(options: {
-    readonly workspaceRoot: string;
+    readonly workspaceRoot?: string;
     readonly registryRoot?: string;
     readonly serverName?: string;
     readonly serverVersion?: string;