@wix/pathgrade 1.0.25 → 1.0.26

package/README.md

@@ -375,6 +375,48 @@ Use `getMcpApproval()` for the simulated-user decision and
 observed. Mock responses are fixed fixtures; this mode does not model stateful
 mutation or make later reads observe earlier writes.
 
+### Direct MCP scenario machine v2
+
+`ScenarioMachineV2` is the versioned stateful MCP contract. Its parent-owned
+host controls matching, transitions, cancellation, evidence, and replay. Cases
+are unordered, disjoint JSON constraints; callbacks and regexes are rejected.
+Concurrent calls involving a transition-capable tool poison the scenario. This
+safety behavior is a fixed V2 invariant and is not author-configurable.
+
+```ts
+import {
+  compileScenario,
+  getFinalScenarioState,
+  getScenarioStateTimeline,
+  wasScenarioCaseMatched,
+  type ScenarioMachineV2,
+} from '@wix/pathgrade';
+
+declare const scenario: ScenarioMachineV2;
+const compiled = compileScenario(scenario);
+if (!compiled.ok) throw new Error(JSON.stringify(compiled.diagnostics));
+declare const evidence: Parameters<typeof getFinalScenarioState>[0];
+wasScenarioCaseMatched(evidence, { caseId: 'CreateDocument' });
+getScenarioStateTimeline(evidence);
+getFinalScenarioState(evidence);
+```
+
+Evidence helpers validate the hash chain and reject empty, corrupt, or
+cross-trial evidence. Provider lifecycle events are corroboration only.
+
+#### Legacy migration window
+Existing `mcpMock` descriptors remain supported with no scheduled removal. They
+retain ordered regexes, fallback behavior, and receipts. V2 migration is
+explicit; receipt settlement has no v2 authority or new features. Removing the
+legacy executor would require a new owner-approved ADR and a major release.
+
+The public live author path requires an explicit `agent`. It supports Claude,
+Codex app-server, OpenCode ACP, and Cursor ACP when the checked-in exact runtime
+lock for the current provider, platform, architecture, and version is admitted.
+Codex `exec` is unsupported. OpenCode requires its existing absolute
+`opencodeExecutable` option and uses the default API-key model for Scenario V2;
+provider-specific scenario flags and profile controls are not public.
+
 ## CLI
 
 ```bash

package/dist/agents/claude/sdk-options.d.ts

@@ -1,5 +1,4 @@
 import type { CanUseTool, Options, SpawnedProcess, SpawnOptions as SdkSpawnOptions } from '@anthropic-ai/claude-agent-sdk';
-import type { McpServersObject } from '../../providers/mcp-runtime-mounting.js';
 export interface ClaudeSdkOptionsInputs {
     /** Per-trial workspace; cwd for the SDK so project-staged skills resolve. */
     workspacePath: string;
@@ -32,7 +31,7 @@ export interface ClaudeSdkOptionsInputs {
      */
     resume?: string;
     /** MCP servers in the SDK's object form, from `mountMcpForClaudeSdk`. */
-    mcpServers?: McpServersObject;
+    mcpServers?: Options['mcpServers'];
     /** Per-turn cancellation controller linked to PathGrade's turn timeout. */
     abortController?: AbortController;
 }

package/dist/agents/claude.js

@@ -102,7 +102,8 @@ export class ClaudeAgent extends BaseAgent {
             mcpSafety: sessionOptions?.mcpSafety,
         });
         await assertStdioMcpServersStartForClaudeSdk(mcpMountOptions);
-        const mcpServers = sessionOptions?.scriptedMcpHost?.claudeServers
+        const mcpServers = sessionOptions?.scenarioMcpServers
+            ?? sessionOptions?.scriptedMcpHost?.claudeServers
             ?? await mountMcpForClaudeSdk(mcpMountOptions);
         let priorSessionId;
         let turnNumber = 0;

package/dist/agents/codex-app-server/agent.js

@@ -40,6 +40,29 @@ function projectMcpStartupStatusIntoTurn(params, turn) {
         failTurn(turn, message);
     }
 }
+function dispatchCodexNotification(notification, turn, sensitiveValues) {
+    if (process.env.PATHGRADE_CODEX_DEBUG) {
+        const debugParams = sanitizePersistenceValue(notification.params, sensitiveValues);
+        console.error(`[codex app-server] notification method=${notification.method} params=${JSON.stringify(debugParams).slice(0, 300)}`);
+    }
+    if (notification.method === 'mcpServer/startupStatus/updated') {
+        if (turn) {
+            projectMcpStartupStatusIntoTurn((notification.params ?? {}), turn);
+        }
+        return;
+    }
+    if (!turn)
+        return;
+    const params = notification.params;
+    if (notification.method === 'item/started') {
+        if (params)
+            turn.itemLifecycle?.receiveStarted(params);
+        return;
+    }
+    if (notification.method === 'item/completed' && params) {
+        turn.itemLifecycle?.receiveCompleted(params);
+    }
+}
 function failTurn(turn, message) {
     turn.turnFailed = true;
     turn.failureMessage = message;
@@ -79,7 +102,11 @@ export class CodexAppServerAgent extends BaseAgent {
         const askBus = requireAskBusForLiveBatches(options, 'CodexAppServerAgent');
         const workspacePath = getWorkspacePath(runtime);
         const runtimeEnv = getRuntimeEnv(runtime);
-        const sensitiveValues = collectSensitiveEnvValues(runtimeEnv);
+        const scenarioMount = options?.codexScenarioMount;
+        const sensitiveValues = [...new Set([
+                ...collectSensitiveEnvValues(runtimeEnv),
+                ...(scenarioMount?.sensitiveValues ?? []),
+            ])];
         const model = resolveCodexModel(options?.model);
         const sandboxMode = this.deps.sandboxMode ?? 'workspace-write';
         await assertUnsupportedLiveMcpSafetyRuntime({
@@ -112,6 +139,28 @@ export class CodexAppServerAgent extends BaseAgent {
                 throw new Error('CodexAppServerAgent session disposed');
             if (handle)
                 return handle.transport;
+            if (scenarioMount) {
+                handle = scenarioMount.handle;
+                const transport = handle.transport;
+                transport.onServerRequest((req) => this.dispatchServerRequest(req, {
+                    transport,
+                    askBus,
+                    activeTurn: () => activeTurn,
+                    mcpSafety: options?.mcpSafety,
+                    scriptedHost,
+                    correlator,
+                    managedAuth,
+                }));
+                transport.onClose((info) => {
+                    if (handle === scenarioMount.handle)
+                        closeInfo = info;
+                });
+                transport.onNotification((n) => {
+                    dispatchCodexNotification(n, activeTurn, sensitiveValues);
+                });
+                await managedAuth.login(transport);
+                return transport;
+            }
             const factory = this.deps.createTransport
                 ?? (async (ctx) => spawnAppServerTransport({ cwd: ctx.workspacePath, env: ctx.env,
                     args: scriptedHost ? ['--enable', 'tool_call_mcp_elicitation'] : [] }));
@@ -132,30 +181,7 @@ export class CodexAppServerAgent extends BaseAgent {
                     closeInfo = info;
             });
             transport.onNotification((n) => {
-                if (process.env.PATHGRADE_CODEX_DEBUG) {
-                    const debugParams = sanitizePersistenceValue(n.params, sensitiveValues);
-                    console.error(`[codex app-server] notification method=${n.method} params=${JSON.stringify(debugParams).slice(0, 300)}`);
-                }
-                if (n.method === 'mcpServer/startupStatus/updated') {
-                    const turn = activeTurn;
-                    if (turn) {
-                        projectMcpStartupStatusIntoTurn((n.params ?? {}), turn);
-                    }
-                    return;
-                }
-                const turn = activeTurn;
-                if (!turn)
-                    return;
-                const params = n.params;
-                if (n.method === 'item/started') {
-                    if (params)
-                        turn.itemLifecycle?.receiveStarted(params);
-                    return;
-                }
-                if (n.method !== 'item/completed')
-                    return;
-                if (params)
-                    turn.itemLifecycle?.receiveCompleted(params);
+                dispatchCodexNotification(n, activeTurn, sensitiveValues);
             });
             const initialize = async () => {
                 const initialized = await transport.sendRequest('initialize', {
@@ -179,6 +205,7 @@ export class CodexAppServerAgent extends BaseAgent {
         const runTurn = async (message) => {
             const t = await ensureTransport();
             const turnHandle = handle;
+            scenarioMount?.prepareProviderTurn();
             turnCounter += 1;
             const turn = {
                 turnNumber: turnCounter,
@@ -202,7 +229,7 @@ export class CodexAppServerAgent extends BaseAgent {
                             env: runtimeEnv,
                         });
                     }
-                    const mcpConfig = scriptedHost?.codexConfig ?? (options?.mcpConfigPath
+                    const mcpConfig = scenarioMount?.config ?? scriptedHost?.codexConfig ?? (options?.mcpConfigPath
                         ? await mountMcpForCodexAppServer({
                             workspacePath,
                             mcpConfigPath: options.mcpConfigPath,
@@ -335,12 +362,15 @@ export class CodexAppServerAgent extends BaseAgent {
                     }
                     if (!authoritativeTurnId) {
                         if (!turn.authoritativeTurnId) {
-                            scriptedHost?.failProtocol('turn/start did not return an authoritative turn id');
-                            turn.signalFailure?.('turn/start did not return an authoritative turn id');
+                            const message = 'turn/start did not return an authoritative turn id';
+                            scriptedHost?.failProtocol(message);
+                            scenarioMount?.failProviderTurn(new Error(message));
+                            turn.signalFailure?.(message);
                         }
                         return;
                     }
                     turnStartCanReuseTransport = true;
+                    scenarioMount?.registerProviderTurn(authoritativeThreadId, authoritativeTurnId);
                     markAuthoritativeTurn(authoritativeTurnId);
                 })
                     .catch((err) => {
@@ -352,6 +382,7 @@ export class CodexAppServerAgent extends BaseAgent {
                         : typeof err === 'string'
                             ? err
                             : 'turn/start failed';
+                    scenarioMount?.failProviderTurn(new Error(msg));
                     turn.signalFailure?.(msg);
                 });
                 try {
@@ -399,20 +430,25 @@ export class CodexAppServerAgent extends BaseAgent {
                 activeTurn = null;
                 correlator?.endTurn();
                 const retireTransport = shouldRetireAuthoritativeTurnTransport(authoritativeTurnIds);
-                await closeUncorrelatedTurnTransport({
-                    turnStartCanReuseTransport,
-                    authoritativeTurnId: turn.authoritativeTurnId,
-                    retireTransport,
-                    currentHandle: handle,
-                    turnHandle,
-                    reset: () => {
-                        sessionRetired ||= retireTransport;
-                        handle = null;
-                        threadId = null;
-                        authoritativeTurnIds.clear();
-                        closeInfo = null;
-                    },
-                });
+                if (scenarioMount) {
+                    sessionRetired ||= retireTransport;
+                }
+                else {
+                    await closeUncorrelatedTurnTransport({
+                        turnStartCanReuseTransport,
+                        authoritativeTurnId: turn.authoritativeTurnId,
+                        retireTransport,
+                        currentHandle: handle,
+                        turnHandle,
+                        reset: () => {
+                            sessionRetired ||= retireTransport;
+                            handle = null;
+                            threadId = null;
+                            authoritativeTurnIds.clear();
+                            closeInfo = null;
+                        },
+                    });
+                }
             }
         };
         const dispose = async () => {
@@ -424,7 +460,7 @@ export class CodexAppServerAgent extends BaseAgent {
                 turn.signalFailure?.('session disposed');
             }
             activeTurn = null;
-            if (handle) {
+            if (handle && !scenarioMount) {
                 try {
                     await handle.close();
                 }
@@ -587,8 +623,9 @@ function assembleTurnResult(args) {
         .map((s) => toAskUserToolEvent(s));
     const toolEvents = enrichSkillEvents([...askEvents, ...activeTurn.nonAskToolEvents])
         .map((event) => attachToolEventSensitiveValues(event, sensitiveValues));
+    const sanitizedMessage = sanitizePersistenceValue(message, sensitiveValues);
     const rawOutput = sanitizePersistenceValue(exitCode === 0
-        ? message
+        ? sanitizedMessage
         : [
             message,
             pid !== undefined ? `pid=${pid}` : '',
@@ -599,8 +636,8 @@ function assembleTurnResult(args) {
             .join(' '), sensitiveValues);
     return attachTurnResultSensitiveValues({
         rawOutput,
-        assistantMessage: exitCode === 0 ? message : '',
-        visibleAssistantMessage: exitCode === 0 ? message : '',
+        assistantMessage: exitCode === 0 ? sanitizedMessage : '',
+        visibleAssistantMessage: exitCode === 0 ? sanitizedMessage : '',
         visibleAssistantMessageSource: 'assistant_message',
         exitCode,
         traceOutput: rawOutput,

package/dist/agents/codex-app-server/scenario-mount.d.ts

@@ -0,0 +1,40 @@
+import { type MaterializedProjection } from '../../internal/direct-mcp-v2/materialize.js';
+import { type PublicScenarioRuntime } from '../../internal/direct-mcp-v2/public-scenario-runtime.js';
+import { type RuntimeLock } from '../../internal/direct-mcp-v2/runtime-lock.js';
+import type { ScenarioArtifact } from '../../internal/direct-mcp-v2/types.js';
+import type { CodexAppServerMcpConfig } from '../../providers/mcp-runtime-mounting.js';
+import { type AppServerSessionHandle } from './transport.js';
+/**
+ * Parent-owned, already-admitted Codex app-server attachment for one public
+ * ScenarioMachineV2 session. The driver may use this handle, but it must not
+ * replace or close it; the scenario coordinator owns provider cleanup.
+ */
+export interface CodexScenarioMount {
+    readonly handle: AppServerSessionHandle;
+    readonly config: CodexAppServerMcpConfig;
+    readonly sensitiveValues: readonly string[];
+    prepareProviderTurn(): void;
+    registerProviderTurn(threadId: string, turnId: string): void;
+    failProviderTurn(error: Error): void;
+}
+type CodexScenarioRuntimeOptions = {
+    artifact: ScenarioArtifact;
+    workspacePath: string;
+    environment: Readonly<Record<string, string | undefined>>;
+    onEvidence?(evidence: readonly import('../../internal/direct-mcp-v2/types.js').EvidenceEnvelope[]): void;
+};
+type CodexScenarioRuntimeDependencies = {
+    lock: RuntimeLock;
+    resolveExecutable(environment: Readonly<Record<string, string | undefined>>): Promise<string>;
+    spawn(context: {
+        binary: string;
+        args: readonly string[];
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+    }): AppServerSessionHandle;
+    commandVersion(path: string, args: readonly string[]): Promise<string>;
+};
+/** Coordinator-backed public Codex ScenarioMachineV2 adapter. */
+export declare function startPublicCodexScenarioRuntime(options: CodexScenarioRuntimeOptions, dependencies?: Partial<CodexScenarioRuntimeDependencies>): Promise<PublicScenarioRuntime>;
+export declare function mergeCodexScenarioConfigs(configs: readonly MaterializedProjection[]): CodexAppServerMcpConfig;
+export {};

package/dist/agents/codex-app-server/scenario-mount.js

@@ -0,0 +1,238 @@
+import { materializeProjection } from '../../internal/direct-mcp-v2/materialize.js';
+import { projectEndpoints } from '../../internal/direct-mcp-v2/projection.js';
+import { startScenarioCoordinator, } from '../../internal/direct-mcp-v2/public-scenario-runtime.js';
+import { admitRuntimeLock } from '../../internal/direct-mcp-v2/runtime-lock.js';
+import { CODEX_DIRECT_MCP_DARWIN_ARM64_LOCK, CODEX_DIRECT_MCP_NORMALIZED_HANDSHAKE, resolveCodexScenarioExecutable, } from '../../internal/direct-mcp-v2/codex-profile.js';
+import { spawnAppServerTransport, } from './transport.js';
+const defaultDependencies = {
+    lock: CODEX_DIRECT_MCP_DARWIN_ARM64_LOCK,
+    resolveExecutable: resolveCodexScenarioExecutable,
+    spawn: ({ binary, args, cwd, env }) => spawnAppServerTransport({
+        binary,
+        args,
+        cwd,
+        env,
+        logStderrOnExit: false,
+    }),
+    commandVersion: async (path, args) => {
+        const { execFile } = await import('node:child_process');
+        return await new Promise((resolve, reject) => {
+            execFile(path, [...args], { timeout: 15_000, maxBuffer: 1024 * 1024 }, (error, stdout) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(stdout.trim());
+            });
+        });
+    },
+};
+/** Coordinator-backed public Codex ScenarioMachineV2 adapter. */
+export async function startPublicCodexScenarioRuntime(options, dependencies = {}) {
+    const deps = { ...defaultDependencies, ...dependencies };
+    const coordinator = await startScenarioCoordinator({
+        ...options,
+        provider: 'codex',
+        async attach(context) {
+            const bearer = context.resolveSecret('public-scenario-v2-bearer');
+            let handle;
+            const resolvedExecutable = await deps.resolveExecutable(options.environment);
+            const admission = await admitRuntimeLock(deps.lock, {
+                provider: 'codex',
+                platform: process.platform,
+                architecture: process.arch,
+                resolvedExecutable,
+                environment: options.environment,
+                forbiddenSecrets: [bearer, bearer.slice('Bearer '.length)],
+                commandVersion: deps.commandVersion,
+                initializeControlPlane: async (verifiedCommandPath, codeOwnedArgs) => {
+                    handle = deps.spawn({
+                        binary: verifiedCommandPath,
+                        args: codeOwnedArgs,
+                        cwd: options.workspacePath,
+                        env: { ...options.environment },
+                    });
+                    try {
+                        const initialized = await handle.transport.sendRequest('initialize', {
+                            clientInfo: { name: 'pathgrade', version: '0.5.0', title: null },
+                            capabilities: { experimentalApi: true, optOutNotificationMethods: null },
+                        });
+                        assertCodexHandshake(initialized, deps.lock.version);
+                        handle.transport.sendNotification('initialized', null);
+                        return {
+                            normalizedHandshake: CODEX_DIRECT_MCP_NORMALIZED_HANDSHAKE,
+                            capabilities: deps.lock.capabilities,
+                            close: () => handle.close(),
+                        };
+                    }
+                    catch (error) {
+                        await handle.close().catch(() => undefined);
+                        throw error;
+                    }
+                },
+            });
+            if (!handle)
+                throw new Error('RUNTIME_NOT_ADMITTED: control plane unavailable');
+            try {
+                const plans = projectEndpoints(context.endpoints, admission.profile);
+                if (!Array.isArray(plans))
+                    throw new Error(`RUNTIME_NOT_ADMITTED: ${plans.reason}`);
+                const config = mergeCodexScenarioConfigs(plans.map((plan) => materializeProjection(plan, {
+                    resolve: context.resolveSecret,
+                })));
+                const tracker = createCodexScenarioTurnTracker(handle.transport);
+                const sensitiveValues = [...new Set([
+                        bearer,
+                        bearer.slice('Bearer '.length),
+                        ...context.endpoints.map((endpoint) => endpoint.url),
+                    ])];
+                const mount = {
+                    handle,
+                    config,
+                    sensitiveValues,
+                    prepareProviderTurn: tracker.prepare,
+                    registerProviderTurn: tracker.register,
+                    failProviderTurn: tracker.fail,
+                };
+                return {
+                    value: mount,
+                    interrupt: tracker.interrupt,
+                    waitForTerminal: tracker.waitForTerminal,
+                    async close() {
+                        tracker.dispose();
+                        await handle?.close();
+                    },
+                };
+            }
+            catch (error) {
+                await handle.close().catch(() => undefined);
+                throw error;
+            }
+        },
+    });
+    return {
+        configureSession(sessionOptions) {
+            sessionOptions.codexScenarioMount = coordinator.attachment;
+        },
+        beginTurn: coordinator.beginTurn,
+        settleTurn: coordinator.settleTurn,
+        failTurn: coordinator.failTurn,
+        evidence: coordinator.evidence,
+        dispose: coordinator.dispose,
+    };
+}
+export function mergeCodexScenarioConfigs(configs) {
+    const mcpServers = {};
+    for (const config of configs) {
+        if (config.kind !== 'codex-app-server') {
+            throw new Error('Codex projection materialized as another provider');
+        }
+        Object.assign(mcpServers, config.mcp_servers);
+    }
+    return { mcp_servers: mcpServers };
+}
+function assertCodexHandshake(initialized, expectedVersion) {
+    const version = expectedVersion.replace(/^codex-cli\s+/, '');
+    if (typeof initialized.userAgent !== 'string' || !initialized.userAgent.includes(version)) {
+        throw new Error('Codex initialize userAgent did not match admitted version');
+    }
+}
+function createCodexScenarioTurnTracker(transport) {
+    let active;
+    let resolveActive;
+    let rejectActive;
+    let terminalError;
+    let activeError;
+    const createActiveReady = () => {
+        const ready = new Promise((resolve, reject) => {
+            resolveActive = resolve;
+            rejectActive = reject;
+        });
+        void ready.catch(() => undefined);
+        return ready;
+    };
+    let activeReady = createActiveReady();
+    const completed = new Map();
+    const waiters = new Map();
+    const off = transport.onNotification((notification) => {
+        if (notification.method !== 'turn/completed')
+            return;
+        const params = notification.params;
+        const turnId = params?.turn?.id ?? params?.turnId;
+        if (!turnId)
+            return;
+        const status = params?.turn?.status ?? params?.status ?? 'unknown';
+        const waiter = waiters.get(turnId);
+        if (waiter) {
+            waiters.delete(turnId);
+            waiter.resolve(status);
+        }
+        else {
+            completed.set(turnId, status);
+        }
+    });
+    const closeOff = transport.onClose((info) => {
+        terminalError = Object.assign(new Error('Codex app-server closed before the matching turn terminal'), {
+            exitCode: info.exitCode,
+            signal: info.signal,
+            pid: info.pid,
+        });
+        rejectActive?.(terminalError);
+        for (const waiter of waiters.values())
+            waiter.reject(terminalError);
+        waiters.clear();
+    });
+    const providerTurn = async (_turn) => {
+        if (active)
+            return active;
+        if (activeError)
+            throw activeError;
+        if (terminalError)
+            throw terminalError;
+        return activeReady;
+    };
+    return {
+        prepare() {
+            active = undefined;
+            activeError = undefined;
+            if (terminalError)
+                return;
+            activeReady = createActiveReady();
+        },
+        register(threadId, turnId) {
+            const turn = { threadId, turnId };
+            active = turn;
+            resolveActive?.(turn);
+        },
+        fail(error) {
+            activeError = error;
+            rejectActive?.(error);
+        },
+        async interrupt(turn) {
+            if (terminalError)
+                throw terminalError;
+            const provider = await providerTurn(turn);
+            await transport.sendRequest('turn/interrupt', provider);
+        },
+        async waitForTerminal(turn) {
+            const provider = await providerTurn(turn);
+            if (completed.has(provider.turnId)) {
+                completed.delete(provider.turnId);
+                return;
+            }
+            if (terminalError)
+                throw terminalError;
+            await new Promise((resolve, reject) => waiters.set(provider.turnId, { resolve, reject }));
+        },
+        dispose() {
+            off();
+            closeOff();
+            const error = terminalError ?? new Error('Codex scenario turn tracker disposed');
+            rejectActive?.(error);
+            for (const waiter of waiters.values())
+                waiter.reject(error);
+            active = undefined;
+            completed.clear();
+            waiters.clear();
+        },
+    };
+}

package/dist/agents/cursor-scenario.d.ts

@@ -0,0 +1,20 @@
+import type { AgentSessionOptions } from '../types.js';
+import type { AcpToolNameNormalizer } from '../internal/direct-mcp-v2/acp-author-projector.js';
+import { attachAcpAuthorSession, type AcpAuthorSession } from '../internal/direct-mcp-v2/acp-author-session.js';
+import { startScenarioCoordinator, type PublicScenarioRuntimeFactory } from '../internal/direct-mcp-v2/public-scenario-runtime.js';
+import { resolveCursorExecutable } from '../internal/direct-mcp-v2/cursor-profile.js';
+export declare function setCursorScenarioSession(options: AgentSessionOptions, session: AcpAuthorSession): void;
+export declare function getCursorScenarioSession(options: AgentSessionOptions | undefined): AcpAuthorSession | undefined;
+/** Cursor's admitted ACP build exposes MCP calls only as the stable title `MCP: tool`. */
+export declare const normalizeCursorAcpToolName: AcpToolNameNormalizer;
+type CursorScenarioRuntimeDependencies = {
+    attachAcpAuthorSession: typeof attachAcpAuthorSession;
+    resolveCursorExecutable: typeof resolveCursorExecutable;
+    startScenarioCoordinator: typeof startScenarioCoordinator;
+};
+export type CursorScenarioRuntimeFactoryOptions = {
+    requestedModel?: string;
+};
+export declare function createPublicCursorScenarioRuntimeFactory(factoryOptions?: CursorScenarioRuntimeFactoryOptions, dependencyOverrides?: Partial<CursorScenarioRuntimeDependencies>): PublicScenarioRuntimeFactory;
+export declare const startPublicCursorScenarioRuntime: typeof import("../internal/direct-mcp-v2/public-scenario-runtime.js").startPublicClaudeScenarioRuntime;
+export {};