@wix/pathgrade 1.0.25 → 1.0.26

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

@@ -0,0 +1,163 @@
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { lstat, readFile, realpath } from 'node:fs/promises';
+import { isAbsolute } from 'node:path';
+import { promisify } from 'node:util';
+import { canonicalJson, parseStrictJson, sha256Canonical } from './json.js';
+const execFileAsync = promisify(execFile);
+const SHA256 = /^[a-f0-9]{64}$/;
+const PROVIDERS = ['claude', 'codex', 'cursor', 'opencode'];
+const CONTROL_PLANES = ['native-sdk-parent-bridge', 'app-server', 'acp-v1'];
+const CANCELLATIONS = ['abort-controller', 'turn-interrupt', 'session-cancel'];
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function exactKeys(value, allowed, path) {
+    const extra = Object.keys(value).filter((key) => !allowed.includes(key));
+    if (extra.length > 0)
+        throw new TypeError(`${path}: unknown fields ${extra.sort().join(', ')}`);
+}
+function stringArray(value, path) {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string'))
+        throw new TypeError(`${path}: expected string array`);
+    return value;
+}
+export function profileFingerprint(profile) {
+    return sha256Canonical(profile);
+}
+export function runtimeCapabilityFingerprint(normalizedHandshake) {
+    return sha256Canonical(normalizedHandshake);
+}
+export function parseRuntimeProfile(input) {
+    const value = typeof input === 'string' ? parseStrictJson(input) : input;
+    canonicalJson(value);
+    if (!object(value))
+        throw new TypeError('$: runtime profile must be an object');
+    exactKeys(value, ['format', 'provider', 'platform', 'architecture', 'controlPlane', 'command', 'expectedVersion', 'artifacts', 'requiredCapabilities', 'profileFingerprint', 'runtimeCapabilityFingerprint'], '$');
+    if (value.format !== 'pathgrade-direct-mcp-runtime-profile-v1')
+        throw new TypeError('$/format: unsupported profile format');
+    if (!PROVIDERS.includes(value.provider))
+        throw new TypeError('$/provider: unsupported provider');
+    if (typeof value.platform !== 'string' || typeof value.architecture !== 'string')
+        throw new TypeError('$: platform and architecture must be strings');
+    if (!CONTROL_PLANES.includes(value.controlPlane))
+        throw new TypeError('$/controlPlane: unsupported control plane');
+    if (!object(value.command))
+        throw new TypeError('$/command: expected object');
+    exactKeys(value.command, ['absolutePath', 'args', 'versionArgs'], '$/command');
+    if (typeof value.command.absolutePath !== 'string')
+        throw new TypeError('$/command/absolutePath: expected string');
+    const args = stringArray(value.command.args, '$/command/args');
+    const versionArgs = stringArray(value.command.versionArgs, '$/command/versionArgs');
+    if (typeof value.expectedVersion !== 'string')
+        throw new TypeError('$/expectedVersion: expected string');
+    if (!Array.isArray(value.artifacts) || value.artifacts.length === 0)
+        throw new TypeError('$/artifacts: expected non-empty array');
+    const labels = new Set();
+    const artifacts = value.artifacts.map((entry, index) => {
+        if (!object(entry))
+            throw new TypeError(`$/artifacts/${index}: expected object`);
+        exactKeys(entry, ['label', 'absolutePath', 'sha256'], `$/artifacts/${index}`);
+        if (typeof entry.label !== 'string' || labels.has(entry.label))
+            throw new TypeError(`$/artifacts/${index}/label: expected unique string`);
+        labels.add(entry.label);
+        if (typeof entry.absolutePath !== 'string' || typeof entry.sha256 !== 'string' || !SHA256.test(entry.sha256))
+            throw new TypeError(`$/artifacts/${index}: invalid path or digest`);
+        return { label: entry.label, absolutePath: entry.absolutePath, sha256: entry.sha256 };
+    });
+    if (!object(value.requiredCapabilities))
+        throw new TypeError('$/requiredCapabilities: expected object');
+    exactKeys(value.requiredCapabilities, ['streamableHttp', 'controlPlaneHeaders', 'parentOwnedSdkMcp', 'cancellation'], '$/requiredCapabilities');
+    if (value.requiredCapabilities.streamableHttp !== true || value.requiredCapabilities.controlPlaneHeaders !== true || !CANCELLATIONS.includes(value.requiredCapabilities.cancellation)) {
+        throw new TypeError('$/requiredCapabilities: required MCP capabilities are invalid');
+    }
+    if (value.requiredCapabilities.parentOwnedSdkMcp !== undefined && value.requiredCapabilities.parentOwnedSdkMcp !== true)
+        throw new TypeError('$/requiredCapabilities/parentOwnedSdkMcp: must be true when present');
+    if (typeof value.profileFingerprint !== 'string' || !SHA256.test(value.profileFingerprint) || typeof value.runtimeCapabilityFingerprint !== 'string' || !SHA256.test(value.runtimeCapabilityFingerprint)) {
+        throw new TypeError('$: fingerprints must be lowercase SHA-256');
+    }
+    const parsed = {
+        ...value,
+        provider: value.provider,
+        controlPlane: value.controlPlane,
+        command: { absolutePath: value.command.absolutePath, args, versionArgs },
+        artifacts,
+        requiredCapabilities: value.requiredCapabilities,
+    };
+    const { profileFingerprint: stored, runtimeCapabilityFingerprint: _runtime, ...fingerprinted } = parsed;
+    if (profileFingerprint(fingerprinted) !== stored)
+        throw new TypeError('$/profileFingerprint: fingerprint mismatch');
+    return parsed;
+}
+async function verifyRegularNoSymlink(path) {
+    if (!isAbsolute(path))
+        throw new Error(`path is not absolute: ${path}`);
+    const before = await lstat(path, { bigint: true });
+    if (before.isSymbolicLink() || !before.isFile())
+        throw new Error(`path is not a regular non-symlink file: ${path}`);
+    if (await realpath(path) !== path)
+        throw new Error(`path resolves through a symlink: ${path}`);
+    return { device: before.dev, inode: before.ino, size: before.size, modifiedNs: before.mtimeNs };
+}
+async function verifyUnchanged(path, identity) {
+    const after = await verifyRegularNoSymlink(path);
+    if (after.device !== identity.device || after.inode !== identity.inode || after.size !== identity.size || after.modifiedNs !== identity.modifiedNs) {
+        throw new Error(`file moved or changed during admission: ${path}`);
+    }
+}
+async function fileSha256(path) {
+    return createHash('sha256').update(await readFile(path)).digest('hex');
+}
+function containsForbiddenSurface(values, environment, secrets) {
+    const unsafeName = /(authorization|bearer|api[_-]?key|secret|token)/i;
+    for (const value of values) {
+        if (unsafeName.test(value) || secrets.some((secret) => secret.length > 0 && value.includes(secret)))
+            return `forbidden command argument: ${value.replace(/=.*/, '=<redacted>')}`;
+    }
+    for (const [name, value] of Object.entries(environment)) {
+        if (value !== undefined && secrets.some((secret) => secret.length > 0 && value.includes(secret)))
+            return `forbidden environment entry: ${name}`;
+    }
+    return undefined;
+}
+function capabilitiesEqual(expected, actual) {
+    return canonicalJson(expected) === canonicalJson(actual);
+}
+export async function admitRuntimeProfile(rawProfile, context) {
+    let controlPlane;
+    try {
+        const profile = parseRuntimeProfile(rawProfile);
+        if (profile.provider !== context.provider)
+            throw new Error('provider/profile identity mismatch');
+        if (profile.platform !== context.platform || profile.architecture !== context.architecture)
+            throw new Error('platform or architecture mismatch');
+        const commandIdentity = await verifyRegularNoSymlink(profile.command.absolutePath);
+        const artifactIdentities = new Map();
+        for (const artifact of profile.artifacts) {
+            const identity = await verifyRegularNoSymlink(artifact.absolutePath);
+            artifactIdentities.set(artifact.absolutePath, identity);
+            if (await fileSha256(artifact.absolutePath) !== artifact.sha256)
+                throw new Error(`artifact digest mismatch: ${artifact.label}`);
+            await verifyUnchanged(artifact.absolutePath, identity);
+        }
+        await verifyUnchanged(profile.command.absolutePath, commandIdentity);
+        const version = context.commandVersion
+            ? await context.commandVersion(profile.command.absolutePath, profile.command.versionArgs)
+            : `${(await execFileAsync(profile.command.absolutePath, [...profile.command.versionArgs], { timeout: 15_000, maxBuffer: 1024 * 1024 })).stdout}`.trim();
+        if (version !== profile.expectedVersion)
+            throw new Error('version mismatch');
+        const forbidden = containsForbiddenSurface([...profile.command.args, ...profile.command.versionArgs], context.environment ?? {}, context.forbiddenSecrets ?? []);
+        if (forbidden)
+            throw new Error(forbidden);
+        controlPlane = await context.initializeControlPlane();
+        if (!capabilitiesEqual(profile.requiredCapabilities, controlPlane.capabilities))
+            throw new Error('required capability mismatch');
+        if (runtimeCapabilityFingerprint(controlPlane.normalizedHandshake) !== profile.runtimeCapabilityFingerprint)
+            throw new Error('runtime capability fingerprint drift');
+        return { ok: true, profile: { ...profile, admitted: true }, normalizedHandshake: controlPlane.normalizedHandshake, controlPlane };
+    }
+    catch (error) {
+        await controlPlane?.close().catch(() => undefined);
+        return { ok: false, code: 'RUNTIME_NOT_ADMITTED', reason: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/internal/direct-mcp-v2/scenario-http-host.d.ts

@@ -0,0 +1,24 @@
+import { ScenarioHostReducer } from './host-reducer.js';
+import type { EndpointSpec, ScenarioArtifact } from './types.js';
+export type InvocationBarrier = {
+    caseId: string;
+    wait(): Promise<void>;
+    release(): void;
+    reached(): Promise<void>;
+};
+export type ScenarioHttpHost = {
+    endpoints: readonly EndpointSpec[];
+    secretRef: string;
+    bearer: Buffer;
+    reducer: ScenarioHostReducer;
+    activeTransportCount(): number;
+    waitForQuiescence(timeoutMs: number): Promise<void>;
+    dispose(): Promise<void>;
+};
+export declare function createInvocationBarrier(caseId: string): InvocationBarrier;
+export declare function startScenarioHttpHost(options: {
+    artifact: ScenarioArtifact;
+    reducer: ScenarioHostReducer;
+    barrier?: InvocationBarrier;
+    secretRef?: string;
+}): Promise<ScenarioHttpHost>;

package/dist/internal/direct-mcp-v2/scenario-http-host.js

@@ -0,0 +1,254 @@
+/* oxlint-disable anti-slop/no-unknown-parameters, anti-slop/no-runtime-typeof, anti-slop/no-unknown-returns -- This module parses untrusted HTTP and JSON-RPC input at the host boundary. */
+import { randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, McpError } from '@modelcontextprotocol/sdk/types.js';
+const MAX_BODY_BYTES = 1024 * 1024;
+const PATHGRADE_ERROR_CODES = new Map([
+    ['TURN_NOT_ACTIVE', -32010],
+    ['STALE_TURN_EPOCH', -32011],
+    ['SCENARIO_AMBIGUOUS', -32020],
+    ['SCENARIO_CONCURRENT_EFFECT', -32021],
+    ['SCENARIO_CANCELLED', -32022],
+    ['SCENARIO_DELIVERY_UNKNOWN', -32023],
+]);
+export function createInvocationBarrier(caseId) {
+    let release;
+    let reached;
+    const released = new Promise((resolve) => { release = resolve; });
+    const observed = new Promise((resolve) => { reached = resolve; });
+    let didReach = false;
+    return {
+        caseId,
+        async wait() {
+            if (!didReach) {
+                didReach = true;
+                reached();
+            }
+            await released;
+        },
+        release,
+        reached: () => observed,
+    };
+}
+export async function startScenarioHttpHost(options) {
+    const bearer = Buffer.from(randomBytes(32).toString('base64url'));
+    const routes = new Map();
+    for (const serverId of Object.keys(options.artifact.canonicalIr.servers).sort()) {
+        routes.set(`/${randomBytes(18).toString('base64url')}`, serverId);
+    }
+    const activeTransports = new Set();
+    const quiescenceWaiters = new Set();
+    let closing = false;
+    const listener = createServer(async (request, response) => {
+        await handleRequest(request, response).catch((error) => {
+            if (!response.headersSent)
+                sendText(response, 500, 'scenario host failure');
+            else
+                response.end();
+            if (options.reducer.phase !== 'POISONED' && options.reducer.phase !== 'DISPOSED') {
+                try {
+                    if (options.reducer.phase === 'ACTIVE')
+                        options.reducer.fence();
+                    if (options.reducer.phase === 'FENCING')
+                        options.reducer.abortUncommitted('host-threw');
+                    options.reducer.finalize('poisoned', error instanceof Error ? error.name : 'host-threw');
+                }
+                catch (lifecycleFailure) {
+                    // Cleanup owns this secondary failure and reports remaining resources.
+                    void lifecycleFailure;
+                }
+            }
+        });
+    });
+    async function handleRequest(request, response) {
+        if (closing)
+            return sendText(response, 503, 'closing');
+        if (request.headers.host !== '127.0.0.1' && !request.headers.host?.startsWith('127.0.0.1:'))
+            return sendText(response, 400, 'invalid host');
+        const authorization = request.headers.authorization;
+        if (Array.isArray(authorization) || authorization !== `Bearer ${bearer.toString()}`)
+            return sendText(response, 401, 'unauthorized');
+        if (request.method !== 'POST')
+            return sendText(response, 405, 'method not allowed');
+        const serverId = routes.get(request.url ?? '');
+        if (!serverId)
+            return sendText(response, 404, 'not found');
+        const body = await readJsonBody(request);
+        if (body === undefined)
+            return sendText(response, 400, 'invalid JSON');
+        const declaredServer = options.artifact.canonicalIr.servers[serverId];
+        let committedInvocationId;
+        const serverOptions = { capabilities: { tools: {} } };
+        if (declaredServer.instructions)
+            serverOptions.instructions = declaredServer.instructions;
+        const server = new Server({ name: serverId, version: '2.0.0' }, serverOptions);
+        server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: Object.entries(declaredServer.tools).map(([toolId, tool]) => ({
+                name: toolId,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+                // Scenario transitions mutate only parent-owned mock state. They are
+                // not real-world side effects and must not enter provider approval.
+                annotations: { readOnlyHint: true, idempotentHint: true },
+            })),
+        }));
+        server.setRequestHandler(CallToolRequestSchema, async (call) => {
+            const toolId = call.params.name;
+            const args = asJsonObject(call.params.arguments ?? {});
+            if (!args)
+                throw new McpError(-32602, 'Tool arguments must be a JSON object');
+            const received = options.reducer.receive(serverId, toolId, args);
+            if (!received.ok)
+                throw hostError(received.code, received.invocationId);
+            const invocationId = received.value.invocationId;
+            const matched = options.reducer.match(invocationId);
+            if (!matched.ok) {
+                if (matched.code === 'SCENARIO_INVALID_ARGUMENTS') {
+                    return toolError({ kind: 'tool-error', code: matched.code, message: 'Scenario arguments are invalid', data: { issues: matched.issues ?? [] } });
+                }
+                if (matched.code === 'SCENARIO_NO_MATCH')
+                    return toolError({ kind: 'tool-error', code: matched.code, message: matched.message ?? 'No scenario case matched' });
+                throw hostError(matched.code, invocationId);
+            }
+            if (matched.value.outcome.kind === 'tool-error')
+                return toolError(matched.value.outcome);
+            const prepared = options.reducer.prepare(invocationId);
+            if (!prepared.ok)
+                throw hostError(prepared.code, invocationId);
+            const barrierCase = options.artifact.canonicalIr.states[options.reducer.state]?.tools[`${serverId}/${toolId}`]?.cases.find((entry) => entry.id === options.barrier?.caseId);
+            if (barrierCase?.outcome === matched.value.outcome)
+                await options.barrier?.wait();
+            const committed = options.reducer.commit(invocationId);
+            if (!committed.ok)
+                throw hostError(committed.code, invocationId);
+            committedInvocationId = invocationId;
+            const outcome = committed.value.outcome;
+            if (outcome.kind !== 'success')
+                throw new McpError(-32603, 'Committed outcome was not successful');
+            if (outcome.structuredContent)
+                return { content: outcome.content, structuredContent: outcome.structuredContent };
+            return { content: outcome.content };
+        });
+        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+        activeTransports.add(transport);
+        const releaseTransport = () => {
+            activeTransports.delete(transport);
+            if (activeTransports.size === 0) {
+                for (const resolve of quiescenceWaiters)
+                    resolve();
+                quiescenceWaiters.clear();
+            }
+        };
+        transport.onclose = releaseTransport;
+        try {
+            await server.connect(transport);
+            await transport.handleRequest(request, response, body);
+            if (committedInvocationId)
+                options.reducer.delivery(committedInvocationId, 'response-written');
+        }
+        catch (error) {
+            if (committedInvocationId && options.reducer.phase !== 'POISONED')
+                options.reducer.delivery(committedInvocationId, 'unknown');
+            throw error;
+        }
+        finally {
+            await server.close().catch(() => transport.close().catch(() => undefined));
+            releaseTransport();
+        }
+    }
+    await new Promise((resolve, reject) => {
+        listener.once('error', reject);
+        listener.listen(0, '127.0.0.1', resolve);
+    });
+    const address = listener.address();
+    if (!address || typeof address === 'string' || address.address !== '127.0.0.1') {
+        await closeListener(listener);
+        throw new Error('scenario host did not bind IPv4 loopback');
+    }
+    const secretRef = options.secretRef ?? 'codex-direct-mcp-trial-bearer';
+    const endpoints = [...routes].map(([route, serverId]) => ({
+        serverId,
+        transport: 'streamable-http',
+        url: `http://127.0.0.1:${address.port}${route}`,
+        headers: [{ name: 'Authorization', valueRef: secretRef, exposure: 'control-plane-only' }],
+        lifetime: 'trial',
+        authority: 'scenario-host',
+    }));
+    return {
+        endpoints,
+        secretRef,
+        bearer,
+        reducer: options.reducer,
+        activeTransportCount: () => activeTransports.size,
+        waitForQuiescence(timeoutMs) {
+            if (activeTransports.size === 0)
+                return Promise.resolve();
+            return new Promise((resolve, reject) => {
+                const onQuiescent = () => {
+                    clearTimeout(timer);
+                    resolve();
+                };
+                const timer = setTimeout(() => {
+                    quiescenceWaiters.delete(onQuiescent);
+                    reject(new Error('Timed out waiting for scenario host quiescence'));
+                }, timeoutMs);
+                quiescenceWaiters.add(onQuiescent);
+            });
+        },
+        async dispose() {
+            if (closing)
+                return;
+            closing = true;
+            await Promise.all([...activeTransports].map((transport) => transport.close().catch(() => undefined)));
+            await closeListener(listener);
+        },
+    };
+}
+function toolError(error) {
+    const pathgrade = { version: 1, code: error.code, message: error.message };
+    if (error.data)
+        pathgrade.data = error.data;
+    return {
+        isError: true,
+        content: [{ type: 'text', text: error.message }],
+        structuredContent: { pathgrade },
+    };
+}
+function hostError(code, invocationId) {
+    const data = { pathgradeCode: code };
+    if (invocationId)
+        data.invocationId = invocationId;
+    return new McpError(PATHGRADE_ERROR_CODES.get(code) ?? -32603, code, data);
+}
+function asJsonObject(value) {
+    // SAFETY: the JSON parser guarantees recursive JSON values; this check narrows the root to a non-array object.
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += bytes.length;
+        if (size > MAX_BODY_BYTES)
+            return undefined;
+        chunks.push(bytes);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function sendText(response, status, text) {
+    response.writeHead(status, { 'content-type': 'text/plain; charset=utf-8' });
+    response.end(text);
+}
+async function closeListener(listener) {
+    if (!listener.listening)
+        return;
+    await new Promise((resolve, reject) => listener.close((error) => error ? reject(error) : resolve()));
+}

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

@@ -0,0 +1,233 @@
+export type JsonPrimitive = null | boolean | number | string;
+export type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type Sha256 = string;
+export type HmacSha256 = string;
+export type ProviderId = 'claude' | 'codex' | 'cursor' | 'opencode';
+export type MatchPredicate = {
+    pointer: string;
+    equals: JsonValue;
+} | {
+    pointer: string;
+    present: true;
+} | {
+    pointer: string;
+    absent: true;
+};
+export type MatchExpr = {
+    exactArgs: JsonObject;
+} | {
+    all: [MatchPredicate, ...MatchPredicate[]];
+};
+export type McpContent = JsonObject & {
+    type: string;
+};
+export type ScenarioSuccess = {
+    kind: 'success';
+    content: McpContent[];
+    structuredContent?: JsonObject;
+};
+export type ScenarioToolError = {
+    kind: 'tool-error';
+    code: string;
+    message: string;
+    data?: JsonObject;
+};
+export type ScenarioRejection = {
+    id: string;
+    code: 'SCENARIO_NO_MATCH';
+    message: string;
+};
+export type ScenarioCase = {
+    id: string;
+    when: MatchExpr;
+    outcome: ScenarioSuccess | ScenarioToolError;
+    transition?: {
+        to: string;
+    };
+};
+export type ScenarioMachineV2 = {
+    version: 2;
+    scenarioId: string;
+    initialState: string;
+    servers: Record<string, {
+        instructions?: string;
+        tools: Record<string, {
+            description: string;
+            inputSchema: JsonObject;
+        }>;
+    }>;
+    states: Record<string, {
+        tools: Record<string, {
+            cases: ScenarioCase[];
+            otherwise?: ScenarioRejection;
+        }>;
+    }>;
+    concurrency: 'poison-effectful-overlap';
+};
+export type ScenarioDiagnostic = {
+    code: string;
+    path: string;
+    message: string;
+};
+export type CompiledTool = {
+    qualifiedToolId: string;
+    serverId: string;
+    toolId: string;
+    cases: ScenarioCase[];
+    otherwise: ScenarioRejection;
+    effectful: boolean;
+};
+export type ScenarioIR = {
+    version: 2;
+    scenarioId: string;
+    initialState: string;
+    servers: ScenarioMachineV2['servers'];
+    states: Record<string, {
+        tools: Record<string, CompiledTool>;
+    }>;
+    reachableStates: string[];
+    concurrency: 'poison-effectful-overlap';
+};
+export type ScenarioArtifact = {
+    format: 'pathgrade-scenario-machine-v2';
+    canonicalIr: ScenarioIR;
+    artifactDigest: Sha256;
+};
+export type HeaderRef = {
+    name: 'Authorization';
+    valueRef: string;
+    exposure: 'control-plane-only';
+};
+export type EndpointSpec = {
+    serverId: string;
+    transport: 'streamable-http';
+    url: string;
+    headers: readonly HeaderRef[];
+    lifetime: 'trial';
+    authority: 'scenario-host';
+};
+export type ScenarioProviderTurn = {
+    turnId: string;
+    provider: ProviderId;
+};
+/**
+ * Trusted control-plane handle owned by a provider adapter. The coordinator
+ * deliberately treats `value` as opaque and owns only its lifecycle.
+ */
+export type ScenarioProviderAttachment<T> = {
+    value: T;
+    interrupt(turn: ScenarioProviderTurn, reason: string): Promise<void>;
+    waitForTerminal(turn: ScenarioProviderTurn): Promise<void>;
+    close(): Promise<void>;
+};
+export type ScenarioProviderAttachContext = {
+    artifact: ScenarioArtifact;
+    endpoints: readonly EndpointSpec[];
+    resolveSecret(secretRef: string): string;
+};
+export type RuntimeCapabilityProfile = {
+    format: 'pathgrade-direct-mcp-runtime-profile-v1';
+    provider: ProviderId;
+    platform: string;
+    architecture: string;
+    controlPlane: 'native-sdk-parent-bridge' | 'app-server' | 'acp-v1';
+    command: {
+        absolutePath: string;
+        args: readonly string[];
+        versionArgs: readonly string[];
+    };
+    expectedVersion: string;
+    artifacts: readonly {
+        label: string;
+        absolutePath: string;
+        sha256: Sha256;
+    }[];
+    requiredCapabilities: {
+        streamableHttp: true;
+        controlPlaneHeaders: true;
+        parentOwnedSdkMcp?: true;
+        cancellation: 'abort-controller' | 'turn-interrupt' | 'session-cancel';
+    };
+    profileFingerprint: Sha256;
+    runtimeCapabilityFingerprint: Sha256;
+};
+export type AdmittedRuntimeProfile = RuntimeCapabilityProfile & {
+    admitted: true;
+};
+export type ScenarioEvidence = {
+    type: 'turn.begun';
+    epoch: number;
+    provider: ProviderId;
+} | {
+    type: 'mcp.invocation';
+    invocationId: string;
+    receivedSeq: number;
+    turnEpoch: number;
+    serverId: string;
+    toolId: string;
+    argsMac: HmacSha256;
+    replayRequestRef: string;
+    snapshotSeq: number;
+    stateBefore: string;
+} | {
+    type: 'mcp.decision';
+    invocationId: string;
+    authority: 'scenario-host';
+    outcome: 'matched' | 'no-match' | 'ambiguous';
+    caseId?: string;
+} | {
+    type: 'mcp.prepared';
+    invocationId: string;
+    turnEpoch: number;
+} | {
+    type: 'mcp.commit';
+    invocationId: string;
+    committedEpoch: number;
+    stateBefore: string;
+    stateAfter: string;
+    outcomeMac: HmacSha256;
+} | {
+    type: 'mcp.abort';
+    invocationId: string;
+    phase: 'received' | 'matched' | 'prepared';
+    reason: string;
+} | {
+    type: 'mcp.delivery';
+    invocationId: string;
+    status: 'response-written' | 'cancelled' | 'unknown';
+} | {
+    type: 'turn.fenced';
+    previousEpoch: number;
+    nextEpoch: number;
+} | {
+    type: 'domain.poisoned';
+    reason: string;
+    invocationIds: string[];
+} | {
+    type: 'turn.finalized';
+    status: 'settled' | 'cancelled-clean' | 'poisoned';
+    reason?: string;
+    state?: string;
+};
+export type EvidenceEnvelope = {
+    trialId: string;
+    turnId: string;
+    seq: number;
+    previousEventHash: Sha256 | null;
+    eventHash: Sha256;
+    artifactDigest: Sha256;
+    payload: ScenarioEvidence;
+};
+export type ProviderCorroboration = {
+    provider: ProviderId;
+    providerCallId?: string;
+    serverId?: string;
+    toolId?: string;
+    inputDigest?: string;
+    outputDigest?: string;
+    phase: string;
+    order: number;
+};

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

@@ -0,0 +1 @@
+export {};