@wix/pathgrade 1.0.24 → 1.0.26

package/dist/internal/direct-mcp-v2/json.js

@@ -0,0 +1,220 @@
+import { createHash } from 'node:crypto';
+function assertValidString(value, path) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xD800 && code <= 0xDBFF) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xDC00 && next <= 0xDFFF))
+                throw new TypeError(`${path}: unpaired high surrogate`);
+            index += 1;
+        }
+        else if (code >= 0xDC00 && code <= 0xDFFF) {
+            throw new TypeError(`${path}: unpaired low surrogate`);
+        }
+    }
+}
+export function assertJsonValue(value, path = '$', ancestors = new Set()) {
+    if (value === null || typeof value === 'boolean')
+        return;
+    if (typeof value === 'string')
+        return assertValidString(value, path);
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value) || Object.is(value, -0))
+            throw new TypeError(`${path}: invalid JSON number`);
+        if (Number.isInteger(value) && !Number.isSafeInteger(value))
+            throw new TypeError(`${path}: unsafe integer`);
+        return;
+    }
+    if (typeof value !== 'object')
+        throw new TypeError(`${path}: non-JSON value`);
+    if (ancestors.has(value))
+        throw new TypeError(`${path}: cyclic value`);
+    ancestors.add(value);
+    if (Array.isArray(value)) {
+        const keys = Reflect.ownKeys(value);
+        for (let index = 0; index < value.length; index += 1) {
+            if (!Object.prototype.hasOwnProperty.call(value, index))
+                throw new TypeError(`${path}: sparse array`);
+            assertJsonValue(value[index], `${path}/${index}`, ancestors);
+        }
+        if (keys.some((key) => key !== 'length' && (typeof key !== 'string' || !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= value.length))) {
+            throw new TypeError(`${path}: non-index array property`);
+        }
+    }
+    else {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null)
+            throw new TypeError(`${path}: non-plain object`);
+        for (const key of Reflect.ownKeys(value)) {
+            if (typeof key !== 'string')
+                throw new TypeError(`${path}: symbol key`);
+            assertValidString(key, `${path} key`);
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor.enumerable || !('value' in descriptor))
+                throw new TypeError(`${path}/${key}: accessor or hidden property`);
+            assertJsonValue(descriptor.value, `${path}/${escapePointerToken(key)}`, ancestors);
+        }
+    }
+    ancestors.delete(value);
+}
+export function canonicalJson(value) {
+    assertJsonValue(value);
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    const keys = Object.keys(value).sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(',')}}`;
+}
+export function sha256Canonical(value) {
+    return createHash('sha256').update(canonicalJson(value)).digest('hex');
+}
+export function escapePointerToken(token) {
+    return token.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+export function parsePointer(pointer) {
+    if (pointer === '')
+        return [];
+    if (!pointer.startsWith('/'))
+        throw new TypeError(`invalid JSON Pointer: ${pointer}`);
+    return pointer.slice(1).split('/').map((token) => {
+        if (/~(?:[^01]|$)/.test(token))
+            throw new TypeError(`invalid JSON Pointer escape: ${pointer}`);
+        return token.replaceAll('~1', '/').replaceAll('~0', '~');
+    });
+}
+export const MISSING = Symbol('missing-json-pointer');
+export function resolvePointer(value, pointer) {
+    let current = value;
+    for (const token of parsePointer(pointer)) {
+        if (current === MISSING || current === null || typeof current !== 'object')
+            return MISSING;
+        if (Array.isArray(current)) {
+            if (!/^(0|[1-9]\d*)$/.test(token) || Number(token) >= current.length)
+                return MISSING;
+            current = current[Number(token)];
+        }
+        else {
+            current = Object.prototype.hasOwnProperty.call(current, token) ? current[token] : MISSING;
+        }
+    }
+    return current;
+}
+class StrictJsonParser {
+    text;
+    index = 0;
+    constructor(text) {
+        this.text = text;
+    }
+    parse() {
+        const value = this.value('$');
+        this.space();
+        if (this.index !== this.text.length)
+            this.fail('trailing input');
+        assertJsonValue(value);
+        return value;
+    }
+    value(path) {
+        this.space();
+        const char = this.text[this.index];
+        if (char === '{')
+            return this.object(path);
+        if (char === '[')
+            return this.array(path);
+        if (char === '"')
+            return this.string();
+        if (char === 't')
+            return this.literal('true', true);
+        if (char === 'f')
+            return this.literal('false', false);
+        if (char === 'n')
+            return this.literal('null', null);
+        if (char === '-' || (char >= '0' && char <= '9'))
+            return this.number();
+        return this.fail('expected JSON value');
+    }
+    object(path) {
+        this.index += 1;
+        const result = {};
+        const keys = new Set();
+        this.space();
+        if (this.take('}'))
+            return result;
+        while (true) {
+            this.space();
+            if (this.text[this.index] !== '"')
+                this.fail('expected object key');
+            const key = this.string();
+            if (keys.has(key))
+                this.fail(`duplicate key ${JSON.stringify(key)}`);
+            keys.add(key);
+            this.space();
+            if (!this.take(':'))
+                this.fail('expected colon');
+            result[key] = this.value(`${path}/${escapePointerToken(key)}`);
+            this.space();
+            if (this.take('}'))
+                return result;
+            if (!this.take(','))
+                this.fail('expected comma');
+        }
+    }
+    array(path) {
+        this.index += 1;
+        const result = [];
+        this.space();
+        if (this.take(']'))
+            return result;
+        while (true) {
+            result.push(this.value(`${path}/${result.length}`));
+            this.space();
+            if (this.take(']'))
+                return result;
+            if (!this.take(','))
+                this.fail('expected comma');
+        }
+    }
+    string() {
+        const start = this.index;
+        this.index += 1;
+        while (this.index < this.text.length) {
+            const char = this.text[this.index++];
+            if (char === '"') {
+                const value = JSON.parse(this.text.slice(start, this.index));
+                assertValidString(value, `offset ${start}`);
+                return value;
+            }
+            if (char === '\\')
+                this.index += 1;
+            else if (char < ' ')
+                this.fail('unescaped control character');
+        }
+        return this.fail('unterminated string');
+    }
+    number() {
+        const rest = this.text.slice(this.index);
+        const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(rest);
+        if (!match)
+            return this.fail('invalid number');
+        this.index += match[0].length;
+        const value = Number(match[0]);
+        if (!Number.isFinite(value) || Object.is(value, -0) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
+            return this.fail('number outside supported JSON domain');
+        }
+        return value;
+    }
+    literal(token, value) {
+        if (!this.text.startsWith(token, this.index))
+            this.fail(`expected ${token}`);
+        this.index += token.length;
+        return value;
+    }
+    space() { while (/\s/.test(this.text[this.index] ?? ''))
+        this.index += 1; }
+    take(char) { if (this.text[this.index] !== char)
+        return false; this.index += 1; return true; }
+    fail(message) { throw new SyntaxError(`${message} at offset ${this.index}`); }
+}
+export function parseStrictJson(text) {
+    return new StrictJsonParser(text).parse();
+}

package/dist/internal/direct-mcp-v2/materialize.d.ts

@@ -0,0 +1,39 @@
+import type { ProjectionPlan } from './projection.js';
+export interface TrialSecretVault {
+    resolve(secretRef: string): string;
+}
+type MaterializedHeader = {
+    name: 'Authorization';
+    value: string;
+};
+export type MaterializedProjection = {
+    provider: 'claude';
+    kind: 'claude-parent-bridge';
+    server: {
+        name: string;
+        endpoint: {
+            transport: 'streamable-http';
+            url: string;
+            headers: MaterializedHeader[];
+        };
+    };
+} | {
+    provider: 'codex';
+    kind: 'codex-app-server';
+    mcp_servers: Record<string, {
+        url: string;
+        http_headers: Record<string, string>;
+        enabled: true;
+    }>;
+} | {
+    provider: 'cursor' | 'opencode';
+    kind: 'acp-session';
+    mcpServers: {
+        type: 'http';
+        name: string;
+        url: string;
+        headers: MaterializedHeader[];
+    }[];
+};
+export declare function materializeProjection(plan: ProjectionPlan, vault: TrialSecretVault): MaterializedProjection;
+export {};

package/dist/internal/direct-mcp-v2/materialize.js

@@ -0,0 +1,22 @@
+function resolveHeaders(headers, vault) {
+    return headers.map((header) => {
+        const value = vault.resolve(header.valueRef);
+        if (value.length === 0)
+            throw new Error(`secret reference is empty: ${header.valueRef}`);
+        return { name: header.name, value };
+    });
+}
+export function materializeProjection(plan, vault) {
+    if (plan.projection.kind === 'claude-parent-bridge') {
+        const { server } = plan.projection;
+        return { provider: 'claude', kind: 'claude-parent-bridge', server: { ...server, endpoint: { ...server.endpoint, headers: resolveHeaders(server.endpoint.headers, vault) } } };
+    }
+    if (plan.projection.kind === 'codex-app-server') {
+        const { mcpServer } = plan.projection;
+        const headers = Object.fromEntries(resolveHeaders(mcpServer.httpHeaders, vault).map(({ name, value }) => [name, value]));
+        return { provider: 'codex', kind: 'codex-app-server', mcp_servers: { [mcpServer.name]: { url: mcpServer.url, http_headers: headers, enabled: true } } };
+    }
+    const { mcpServer } = plan.projection;
+    const provider = plan.provider;
+    return { provider, kind: 'acp-session', mcpServers: [{ ...mcpServer, headers: resolveHeaders(mcpServer.headers, vault) }] };
+}

package/dist/internal/direct-mcp-v2/opencode-direct-mcp.d.ts

@@ -0,0 +1,14 @@
+import { runAcpDirectMcpTrial, type AcpDirectMcpTrialResult } from './acp-direct-mcp.js';
+import type { ScenarioMachineV2 } from './types.js';
+export declare const OPENCODE_DIRECT_MCP_FLAG = "PATHGRADE_INTERNAL_OPENCODE_DIRECT_MCP_V2";
+export declare function isOpenCodeDirectMcpSelected(environment?: NodeJS.ProcessEnv): boolean;
+export declare function openCodeDirectMcpDisableReason(): string | undefined;
+/** Test-only reset for proving the fail-closed process latch. */
+export declare function __resetOpenCodeDirectMcpDisablementForTesting(): void;
+export declare function mapOpenCodeDirectMcpEnvironment(environment: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function runOpenCodeDirectMcpTrial(options: {
+    scenario: ScenarioMachineV2;
+    environment?: NodeJS.ProcessEnv;
+    artifactDirectory?: string;
+    createClient?: Parameters<typeof runAcpDirectMcpTrial>[0]['createClient'];
+}): Promise<AcpDirectMcpTrialResult>;

package/dist/internal/direct-mcp-v2/opencode-direct-mcp.js

@@ -0,0 +1,71 @@
+import { curateAcpProcessEnvironment, runAcpDirectMcpTrial } from './acp-direct-mcp.js';
+import { OPENCODE_DIRECT_MCP_DARWIN_ARM64_PROFILE } from './opencode-profile.js';
+export const OPENCODE_DIRECT_MCP_FLAG = 'PATHGRADE_INTERNAL_OPENCODE_DIRECT_MCP_V2';
+const disabledProfiles = new Map();
+const OPENCODE_RUNTIME_ENV = {
+    OPENCODE_CLIENT: 'pathgrade',
+    OPENCODE_DISABLE_AUTOUPDATE: '1',
+    OPENCODE_DISABLE_PRUNE: '1',
+    OPENCODE_DISABLE_MODELS_FETCH: '1',
+    OPENCODE_DISABLE_EXTERNAL_SKILLS: '1',
+    OPENCODE_DISABLE_LSP_DOWNLOAD: '1',
+    OPENCODE_DISABLE_SHARE: '1',
+    OPENCODE_DISABLE_DEFAULT_PLUGINS: '1',
+    OPENCODE_PURE: '1',
+};
+export function isOpenCodeDirectMcpSelected(environment = process.env) {
+    return environment[OPENCODE_DIRECT_MCP_FLAG] === '1' && !disabledProfiles.has(OPENCODE_DIRECT_MCP_DARWIN_ARM64_PROFILE.profileFingerprint);
+}
+export function openCodeDirectMcpDisableReason() {
+    return disabledProfiles.get(OPENCODE_DIRECT_MCP_DARWIN_ARM64_PROFILE.profileFingerprint);
+}
+/** Test-only reset for proving the fail-closed process latch. */
+// oxlint-disable-next-line inhuman/no-empty-wrappers -- This test seam exposes Map.clear without exposing mutable production state.
+export function __resetOpenCodeDirectMcpDisablementForTesting() {
+    disabledProfiles.clear();
+}
+export function mapOpenCodeDirectMcpEnvironment(environment) {
+    const result = { ...curateAcpProcessEnvironment(environment), ...OPENCODE_RUNTIME_ENV };
+    const appAnthropicKey = environment.APP_ANTHROPIC_API_KEY;
+    const appAnthropicBaseUrl = environment.APP_ANTHROPIC_BASE_URL;
+    const appOpenAiKey = environment.APP_OPENAI_API_KEY;
+    const appOpenAiBaseUrl = environment.APP_OPENAI_BASE_URL;
+    const anthropicKey = environment.ANTHROPIC_API_KEY ?? appAnthropicKey;
+    const anthropicBaseUrl = environment.ANTHROPIC_BASE_URL ?? appAnthropicBaseUrl;
+    const openAiKey = environment.OPENAI_API_KEY ?? appOpenAiKey;
+    const openAiBaseUrl = environment.OPENAI_BASE_URL ?? appOpenAiBaseUrl;
+    if (anthropicKey)
+        result.ANTHROPIC_API_KEY = anthropicKey;
+    if (anthropicBaseUrl)
+        result.ANTHROPIC_BASE_URL = anthropicBaseUrl;
+    if (openAiKey)
+        result.OPENAI_API_KEY = openAiKey;
+    if (openAiBaseUrl)
+        result.OPENAI_BASE_URL = openAiBaseUrl;
+    return result;
+}
+export async function runOpenCodeDirectMcpTrial(options) {
+    const environment = options.environment ?? process.env;
+    if (!isOpenCodeDirectMcpSelected(environment)) {
+        const reason = openCodeDirectMcpDisableReason();
+        throw new Error(reason ? `OpenCode direct MCP disabled for admitted profile: ${reason}` : `${OPENCODE_DIRECT_MCP_FLAG} is disabled`);
+    }
+    try {
+        const runtimeEnvironment = mapOpenCodeDirectMcpEnvironment(environment);
+        if (!runtimeEnvironment.ANTHROPIC_API_KEY && !runtimeEnvironment.OPENAI_API_KEY) {
+            throw new Error('RUNTIME_NOT_ADMITTED: OpenCode direct MCP requires ANTHROPIC_API_KEY or OPENAI_API_KEY (APP_ANTHROPIC_API_KEY and APP_OPENAI_API_KEY aliases are accepted)');
+        }
+        return await runAcpDirectMcpTrial({
+            provider: 'opencode',
+            scenario: options.scenario,
+            environment: runtimeEnvironment,
+            profile: OPENCODE_DIRECT_MCP_DARWIN_ARM64_PROFILE,
+            artifactDirectory: options.artifactDirectory,
+            createClient: options.createClient,
+        });
+    }
+    catch (error) {
+        disabledProfiles.set(OPENCODE_DIRECT_MCP_DARWIN_ARM64_PROFILE.profileFingerprint, (error instanceof Error ? error.message : String(error)).slice(0, 500));
+        throw error;
+    }
+}

package/dist/internal/direct-mcp-v2/opencode-profile.d.ts

@@ -0,0 +1,8 @@
+import type { AcpNormalizedHandshake } from './acp-client.js';
+import type { RuntimeLock } from './runtime-lock.js';
+import type { RuntimeCapabilityProfile } from './types.js';
+export declare const OPENCODE_DIRECT_MCP_NORMALIZED_HANDSHAKE: AcpNormalizedHandshake;
+/** Code-owned public author-session lock. Installation location is verified separately. */
+export declare const OPENCODE_ACP_DARWIN_ARM64_RUNTIME_LOCK: RuntimeLock;
+/** Reviewed macOS arm64 pin captured by RFC 0006. Other platforms fail closed. */
+export declare const OPENCODE_DIRECT_MCP_DARWIN_ARM64_PROFILE: RuntimeCapabilityProfile;

package/dist/internal/direct-mcp-v2/opencode-profile.js

@@ -0,0 +1,52 @@
+export const OPENCODE_DIRECT_MCP_NORMALIZED_HANDSHAKE = {
+    normalizerVersion: 'pathgrade-acp-v1-capabilities-v1',
+    provider: 'opencode',
+    protocolVersion: 1,
+    httpMcp: true,
+    sessionClose: true,
+};
+/** Code-owned public author-session lock. Installation location is verified separately. */
+export const OPENCODE_ACP_DARWIN_ARM64_RUNTIME_LOCK = {
+    format: 'pathgrade-direct-mcp-runtime-lock-v1',
+    provider: 'opencode',
+    platform: 'darwin',
+    architecture: 'arm64',
+    controlPlane: 'acp-v1',
+    version: '1.18.14',
+    commandArtifact: 'opencode',
+    args: ['acp', '--pure'],
+    versionArgs: ['--version'],
+    artifacts: [{
+            id: 'opencode',
+            relativePath: 'opencode.exe',
+            sha256: '8b7c4e116c1ac5163c02fa85eee5a13d4d00c8a08e677dac4100f55aa56532fa',
+        }],
+    capabilities: {
+        streamableHttp: true,
+        controlPlaneHeaders: true,
+        cancellation: 'session-cancel',
+    },
+    normalizedHandshakeSha256: '481b61c577a70ab7fae2e78d8c2159379675b1007ede488dcf4159f657cece25',
+};
+/** Reviewed macOS arm64 pin captured by RFC 0006. Other platforms fail closed. */
+export const OPENCODE_DIRECT_MCP_DARWIN_ARM64_PROFILE = {
+    format: 'pathgrade-direct-mcp-runtime-profile-v1',
+    provider: 'opencode',
+    platform: 'darwin',
+    architecture: 'arm64',
+    controlPlane: 'acp-v1',
+    command: {
+        absolutePath: '/Users/nadavlac/.nvm/versions/node/v22.18.0/lib/node_modules/opencode-ai/bin/opencode.exe',
+        args: ['acp', '--pure'],
+        versionArgs: ['--version'],
+    },
+    expectedVersion: '1.18.14',
+    artifacts: [{
+            label: 'opencode-1.18.14',
+            absolutePath: '/Users/nadavlac/.nvm/versions/node/v22.18.0/lib/node_modules/opencode-ai/bin/opencode.exe',
+            sha256: '8b7c4e116c1ac5163c02fa85eee5a13d4d00c8a08e677dac4100f55aa56532fa',
+        }],
+    requiredCapabilities: { streamableHttp: true, controlPlaneHeaders: true, cancellation: 'session-cancel' },
+    profileFingerprint: '91f512964bc05b7a8b0cac90444e30c41bb9b0e319aff2341c2a4b72e6e5e3c5',
+    runtimeCapabilityFingerprint: '481b61c577a70ab7fae2e78d8c2159379675b1007ede488dcf4159f657cece25',
+};

package/dist/internal/direct-mcp-v2/projection.d.ts

@@ -0,0 +1,40 @@
+import type { AdmittedRuntimeProfile, EndpointSpec, HeaderRef, ProviderId } from './types.js';
+export type ProjectionRejection = {
+    ok: false;
+    code: 'RUNTIME_NOT_ADMITTED';
+    reason: string;
+};
+export type ProjectionPlan = {
+    ok: true;
+    provider: ProviderId;
+    serverId: string;
+    controlPlane: AdmittedRuntimeProfile['controlPlane'];
+    projection: {
+        kind: 'claude-parent-bridge';
+        server: {
+            name: string;
+            endpoint: {
+                transport: 'streamable-http';
+                url: string;
+                headers: readonly HeaderRef[];
+            };
+        };
+    } | {
+        kind: 'codex-app-server';
+        mcpServer: {
+            name: string;
+            url: string;
+            httpHeaders: readonly HeaderRef[];
+        };
+    } | {
+        kind: 'acp-session';
+        mcpServer: {
+            type: 'http';
+            name: string;
+            url: string;
+            headers: readonly HeaderRef[];
+        };
+    };
+};
+export declare function projectEndpoint(endpoint: EndpointSpec, profile: AdmittedRuntimeProfile): ProjectionPlan | ProjectionRejection;
+export declare function projectEndpoints(endpoints: readonly EndpointSpec[], profile: AdmittedRuntimeProfile): ProjectionPlan[] | ProjectionRejection;

package/dist/internal/direct-mcp-v2/projection.js

@@ -0,0 +1,46 @@
+import { canonicalJson } from './json.js';
+const CONTROL_PLANE = {
+    claude: 'native-sdk-parent-bridge',
+    codex: 'app-server',
+    cursor: 'acp-v1',
+    opencode: 'acp-v1',
+};
+export function projectEndpoint(endpoint, profile) {
+    if (endpoint.transport !== 'streamable-http' || endpoint.authority !== 'scenario-host' || endpoint.lifetime !== 'trial') {
+        return { ok: false, code: 'RUNTIME_NOT_ADMITTED', reason: 'unsupported endpoint contract' };
+    }
+    if (!/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(endpoint.serverId))
+        return { ok: false, code: 'RUNTIME_NOT_ADMITTED', reason: 'projection-unstable server name' };
+    if (!/^http:\/\/127\.0\.0\.1:\d+\/[A-Za-z0-9_-]+$/.test(endpoint.url))
+        return { ok: false, code: 'RUNTIME_NOT_ADMITTED', reason: 'endpoint must use IPv4 loopback and a private route' };
+    if (profile.controlPlane !== CONTROL_PLANE[profile.provider])
+        return { ok: false, code: 'RUNTIME_NOT_ADMITTED', reason: 'provider/control-plane mismatch' };
+    if (endpoint.headers.length !== 1 || endpoint.headers[0].name !== 'Authorization' || endpoint.headers[0].exposure !== 'control-plane-only' || endpoint.headers[0].valueRef.length === 0) {
+        return { ok: false, code: 'RUNTIME_NOT_ADMITTED', reason: 'unsafe header exposure' };
+    }
+    const headers = endpoint.headers.map((header) => ({ ...header }));
+    const base = { ok: true, provider: profile.provider, serverId: endpoint.serverId, controlPlane: profile.controlPlane };
+    if (profile.provider === 'claude') {
+        if (profile.requiredCapabilities.parentOwnedSdkMcp !== true)
+            return { ok: false, code: 'RUNTIME_NOT_ADMITTED', reason: 'Claude requires a parent-owned SDK MCP bridge' };
+        return { ...base, projection: { kind: 'claude-parent-bridge', server: { name: endpoint.serverId, endpoint: { transport: endpoint.transport, url: endpoint.url, headers } } } };
+    }
+    if (profile.provider === 'codex')
+        return { ...base, projection: { kind: 'codex-app-server', mcpServer: { name: endpoint.serverId, url: endpoint.url, httpHeaders: headers } } };
+    return { ...base, projection: { kind: 'acp-session', mcpServer: { type: 'http', name: endpoint.serverId, url: endpoint.url, headers } } };
+}
+export function projectEndpoints(endpoints, profile) {
+    const plans = [];
+    const names = new Set();
+    for (const endpoint of [...endpoints].sort((left, right) => canonicalJson(left.serverId).localeCompare(canonicalJson(right.serverId), 'en'))) {
+        const plan = projectEndpoint(endpoint, profile);
+        if (!plan.ok)
+            return plan;
+        const projectedName = plan.serverId;
+        if (names.has(projectedName))
+            return { ok: false, code: 'RUNTIME_NOT_ADMITTED', reason: `projection collision: ${projectedName}` };
+        names.add(projectedName);
+        plans.push(plan);
+    }
+    return plans;
+}

package/dist/internal/direct-mcp-v2/public-scenario-runtime.d.ts

@@ -0,0 +1,51 @@
+import { type McpSdkServerConfigWithInstance } from '@anthropic-ai/claude-agent-sdk';
+import { type ScanEntry } from './cleanup.js';
+import { type RuntimeLock } from './runtime-lock.js';
+import { startScenarioHttpHost } from './scenario-http-host.js';
+import type { AgentSessionOptions } from '../../types.js';
+import type { EvidenceEnvelope, ProviderId, ScenarioArtifact, ScenarioProviderAttachContext, ScenarioProviderAttachment } from './types.js';
+export type ScenarioCoordinatorHost = typeof startScenarioHttpHost;
+export interface ScenarioCoordinator<TAttachment> {
+    readonly attachment: TAttachment;
+    beginTurn(turnId: string, signal: AbortSignal): void;
+    settleTurn(): Promise<void>;
+    failTurn(error: unknown): Promise<void>;
+    evidence(): readonly EvidenceEnvelope[];
+    dispose(): Promise<void>;
+}
+export type ScenarioCoordinatorOptions<TAttachment> = {
+    artifact: ScenarioArtifact;
+    provider: ProviderId;
+    workspacePath: string;
+    environment: Readonly<Record<string, string | undefined>>;
+    attach(context: ScenarioProviderAttachContext): Promise<ScenarioProviderAttachment<TAttachment>>;
+    onEvidence?(evidence: readonly EvidenceEnvelope[]): void;
+};
+type ScenarioCoordinatorDependencies = {
+    startHost: ScenarioCoordinatorHost;
+    scanBearerSurfaces(roots: readonly string[], bearer: string): Promise<ScanEntry[]>;
+};
+export declare function startScenarioCoordinator<TAttachment>(options: ScenarioCoordinatorOptions<TAttachment>, dependencies?: Partial<ScenarioCoordinatorDependencies>): Promise<ScenarioCoordinator<TAttachment>>;
+export interface PublicScenarioRuntime {
+    /** Adapter-owned, in-memory session projection; never persisted by the coordinator. */
+    configureSession(options: AgentSessionOptions): void;
+    /** Preserved compatibility view for the existing Claude SDK path. */
+    readonly claudeServers?: Record<string, McpSdkServerConfigWithInstance>;
+    beginTurn(turnId: string, signal: AbortSignal): void;
+    settleTurn(): Promise<void>;
+    failTurn(error: unknown): Promise<void>;
+    evidence(): readonly EvidenceEnvelope[];
+    dispose(): Promise<void>;
+}
+export declare function startPublicClaudeScenarioRuntime(options: {
+    artifact: ScenarioArtifact;
+    workspacePath: string;
+    environment: Readonly<Record<string, string | undefined>>;
+    onEvidence?(evidence: readonly EvidenceEnvelope[]): void;
+}, dependencies?: Partial<{
+    lock: RuntimeLock;
+    resolveExecutable(environment: Readonly<Record<string, string | undefined>>): Promise<string>;
+    commandVersion(path: string, args: readonly string[]): Promise<string>;
+}>): Promise<PublicScenarioRuntime>;
+export type PublicScenarioRuntimeFactory = typeof startPublicClaudeScenarioRuntime;
+export {};