@wix/pathgrade 1.0.24 → 1.0.26

package/dist/agents/cursor-scenario.js

@@ -0,0 +1,96 @@
+import { attachAcpAuthorSession, } from '../internal/direct-mcp-v2/acp-author-session.js';
+import { startScenarioCoordinator, } from '../internal/direct-mcp-v2/public-scenario-runtime.js';
+import { CURSOR_ACP_AUTHOR_DARWIN_ARM64_LOCK, resolveCursorExecutable, } from '../internal/direct-mcp-v2/cursor-profile.js';
+import { mapCursorProviderEnvironment } from '../internal/direct-mcp-v2/cursor-direct-mcp.js';
+const scenarioSessions = new WeakMap();
+export function setCursorScenarioSession(options, session) {
+    if (scenarioSessions.has(options))
+        throw new Error('Cursor scenario session is already configured');
+    scenarioSessions.set(options, session);
+}
+export function getCursorScenarioSession(options) {
+    return options ? scenarioSessions.get(options) : undefined;
+}
+/** Cursor's admitted ACP build exposes MCP calls only as the stable title `MCP: tool`. */
+export const normalizeCursorAcpToolName = (title) => title === 'MCP: tool'
+    ? { action: 'mcp_tool_call', providerToolName: 'cursor_mcp_tool' }
+    : { action: 'unknown', providerToolName: title };
+const defaultDependencies = {
+    attachAcpAuthorSession,
+    resolveCursorExecutable,
+    startScenarioCoordinator,
+};
+export function createPublicCursorScenarioRuntimeFactory(factoryOptions = {}, dependencyOverrides = {}) {
+    if (factoryOptions.requestedModel !== undefined) {
+        throw new Error('Cursor Scenario V2 does not support model overrides until the ACP model field is admitted');
+    }
+    const deps = { ...defaultDependencies, ...dependencyOverrides };
+    return async function startPublicCursorScenarioRuntime(options) {
+        const environment = cursorScenarioEnvironment(options.environment);
+        const resolvedExecutable = await deps.resolveCursorExecutable(environment);
+        const coordinator = await deps.startScenarioCoordinator({
+            ...options,
+            provider: 'cursor',
+            attach: async (context) => deps.attachAcpAuthorSession({
+                provider: 'cursor',
+                context,
+                runtimeLock: CURSOR_ACP_AUTHOR_DARWIN_ARM64_LOCK,
+                resolvedExecutable,
+                cwd: options.workspacePath,
+                environment,
+                scanRoots: cursorScanRoots(options.workspacePath, environment),
+                normalizeToolName: normalizeCursorAcpToolName,
+            }),
+        });
+        let configuredOptions;
+        return {
+            configureSession(sessionOptions) {
+                if (sessionOptions.model) {
+                    throw new Error('Cursor Scenario V2 does not support model overrides until the ACP model field is admitted');
+                }
+                if (configuredOptions && configuredOptions !== sessionOptions) {
+                    throw new Error('Cursor Scenario V2 runtime is already configured for another session');
+                }
+                configuredOptions = sessionOptions;
+                setCursorScenarioSession(sessionOptions, coordinator.attachment);
+            },
+            beginTurn: coordinator.beginTurn,
+            settleTurn: coordinator.settleTurn,
+            failTurn: coordinator.failTurn,
+            evidence: coordinator.evidence,
+            async dispose() {
+                try {
+                    await coordinator.dispose();
+                }
+                finally {
+                    if (configuredOptions)
+                        scenarioSessions.delete(configuredOptions);
+                }
+            },
+        };
+    };
+}
+export const startPublicCursorScenarioRuntime = createPublicCursorScenarioRuntimeFactory();
+function cursorScenarioEnvironment(source) {
+    const environment = mapCursorProviderEnvironment(source);
+    for (const name of [
+        'HOME', 'TMPDIR', 'TMP', 'TEMP',
+        'XDG_CONFIG_HOME', 'XDG_DATA_HOME', 'XDG_CACHE_HOME',
+    ]) {
+        if (source[name])
+            environment[name] = source[name];
+    }
+    return environment;
+}
+function cursorScanRoots(workspacePath, environment) {
+    return [...new Set([
+            workspacePath,
+            environment.HOME,
+            environment.TMPDIR,
+            environment.TMP,
+            environment.TEMP,
+            environment.XDG_CONFIG_HOME,
+            environment.XDG_DATA_HOME,
+            environment.XDG_CACHE_HOME,
+        ].filter((path) => typeof path === 'string' && path.length > 0))];
+}

package/dist/agents/cursor.js

@@ -2,6 +2,7 @@ import { BaseAgent, getWorkspacePath } from '../types.js';
 import { TOOL_NAME_MAP, buildSummary, enrichSkillEvents } from '../tool-events.js';
 import { getVisibleAssistantMessage } from '../sdk/visible-turn.js';
 import { prependRuntimePolicies } from '../sdk/runtime-policy.js';
+import { getCursorScenarioSession } from './cursor-scenario.js';
 import { assertUnsupportedLiveMcpSafetyRuntime, mountMcpForCursor, } from '../providers/mcp-runtime-mounting.js';
 /**
  * Cursor tool_call discriminants observed in the discovery spike. Probed in
@@ -150,6 +151,25 @@ export function parseCursorStreamJson(stdout) {
 const CURSOR_EXECUTABLE = 'cursor-agent';
 export class CursorAgent extends BaseAgent {
     async createSession(runtime, runCommand, options) {
+        const scenarioSession = getCursorScenarioSession(options);
+        if (scenarioSession) {
+            if (options?.model) {
+                throw new Error('Cursor Scenario V2 does not support model overrides until the ACP model field is admitted');
+            }
+            let turnNumber = 0;
+            const runScenarioTurn = async (message) => {
+                const appliedRuntimePolicies = turnNumber === 0 ? [...(options?.runtimePolicies ?? [])] : [];
+                const effectiveMessage = appliedRuntimePolicies.length > 0
+                    ? prependRuntimePolicies(message, appliedRuntimePolicies, { agent: 'cursor' })
+                    : message;
+                const result = await scenarioSession.runTurn(effectiveMessage, ++turnNumber);
+                return { ...result, runtimePoliciesApplied: appliedRuntimePolicies };
+            };
+            return {
+                start: async ({ message }) => runScenarioTurn(message),
+                reply: async ({ message }) => runScenarioTurn(message),
+            };
+        }
         const workspacePath = getWorkspacePath(runtime);
         let sessionId;
         return {

package/dist/agents/opencode/scenario.d.ts

@@ -0,0 +1,25 @@
+import type { AgentSessionOptions, AgentTurnResult } from '../../types.js';
+import { attachAcpAuthorSession, type AttachAcpAuthorSessionOptions } from '../../internal/direct-mcp-v2/acp-author-session.js';
+import { type PublicScenarioRuntimeFactory } from '../../internal/direct-mcp-v2/public-scenario-runtime.js';
+export type OpenCodeScenarioRuntimeFactoryOptions = {
+    opencodeExecutable: string;
+    requestedModel?: string;
+};
+type OpenCodeScenarioRuntimePolicy = {
+    readonly model: string;
+    readonly oauth: boolean;
+    environment(): Record<string, string>;
+    beforeTurn(remainingMs: number): Promise<void>;
+    afterTurn(): Promise<void>;
+};
+export type OpenCodeScenarioRuntimeDependencies = {
+    attachAuthorSession(options: AttachAcpAuthorSessionOptions): ReturnType<typeof attachAcpAuthorSession>;
+    createRuntimePolicy(environment: Record<string, string>, requestedModel?: string): Promise<OpenCodeScenarioRuntimePolicy>;
+    assertCleanManagedHost(): Promise<void>;
+};
+export type OpenCodeScenarioSession = {
+    runTurn(message: string): Promise<AgentTurnResult>;
+};
+export declare function getOpenCodeScenarioSession(options: AgentSessionOptions): OpenCodeScenarioSession | undefined;
+export declare function createPublicOpenCodeScenarioRuntimeFactory(factoryOptions: OpenCodeScenarioRuntimeFactoryOptions, dependencyOverrides?: Partial<OpenCodeScenarioRuntimeDependencies>): PublicScenarioRuntimeFactory;
+export {};

package/dist/agents/opencode/scenario.js

@@ -0,0 +1,195 @@
+import * as path from 'node:path';
+import fs from 'fs-extra';
+import { removeSandboxRoot } from '../../providers/sandbox-lifecycle.js';
+import { attachAcpAuthorSession, } from '../../internal/direct-mcp-v2/acp-author-session.js';
+import { startScenarioCoordinator, } from '../../internal/direct-mcp-v2/public-scenario-runtime.js';
+import { OPENCODE_ACP_DARWIN_ARM64_RUNTIME_LOCK } from '../../internal/direct-mcp-v2/opencode-profile.js';
+import { OPENCODE_PERMISSION, OpenCodeRuntimePolicy } from './runtime-policy.js';
+import { assertCleanManagedOpenCodeHost } from './host-safety.js';
+import { DEFAULT_OPENCODE_MODEL, sanitizeOpenCodeToolName } from './contract.js';
+const defaultDependencies = {
+    attachAuthorSession: attachAcpAuthorSession,
+    createRuntimePolicy: OpenCodeRuntimePolicy.create,
+    assertCleanManagedHost: assertCleanManagedOpenCodeHost,
+};
+const configuredSessions = new WeakMap();
+export function getOpenCodeScenarioSession(options) {
+    return configuredSessions.get(options);
+}
+export function createPublicOpenCodeScenarioRuntimeFactory(factoryOptions, dependencyOverrides = {}) {
+    if (factoryOptions.requestedModel !== undefined) {
+        throw new Error(`OpenCode Scenario V2 does not support model overrides; use the default ${DEFAULT_OPENCODE_MODEL} model.`);
+    }
+    const dependencies = { ...defaultDependencies, ...dependencyOverrides };
+    return async (options) => {
+        const environment = definedEnvironment(options.environment);
+        if (!environment.ANTHROPIC_API_KEY?.trim()) {
+            throw new Error(`OpenCode Scenario V2 currently requires API-key authentication using the default model ${DEFAULT_OPENCODE_MODEL}.`);
+        }
+        await dependencies.assertCleanManagedHost();
+        await assertNoProjectConfig(options.workspacePath);
+        const xdgDirectories = isolatedOpenCodeDirectories(environment);
+        await Promise.all(xdgDirectories.map((directory) => fs.ensureDir(directory)));
+        let coordinator;
+        try {
+            const runtimePolicy = await dependencies.createRuntimePolicy(environment);
+            if (runtimePolicy.oauth || runtimePolicy.model !== DEFAULT_OPENCODE_MODEL) {
+                throw new Error(`OpenCode Scenario V2 currently requires API-key authentication using the default model ${DEFAULT_OPENCODE_MODEL}.`);
+            }
+            const providerEnvironment = buildScenarioEnvironment(environment, runtimePolicy, xdgDirectories);
+            const mcpToolNames = scenarioToolNames(options.artifact);
+            coordinator = await startScenarioCoordinator({
+                artifact: options.artifact,
+                workspacePath: options.workspacePath,
+                environment: {
+                    HOME: environment.HOME,
+                    TMPDIR: path.dirname(options.workspacePath),
+                },
+                onEvidence: options.onEvidence,
+                provider: 'opencode',
+                attach: (context) => dependencies.attachAuthorSession({
+                    provider: 'opencode',
+                    context,
+                    runtimeLock: OPENCODE_ACP_DARWIN_ARM64_RUNTIME_LOCK,
+                    resolvedExecutable: factoryOptions.opencodeExecutable,
+                    cwd: options.workspacePath,
+                    environment: providerEnvironment,
+                    scanRoots: scenarioScanRoots(options.workspacePath, providerEnvironment, xdgDirectories),
+                    normalizeToolName: (title) => normalizeOpenCodeToolName(title, mcpToolNames),
+                }),
+            });
+            let configuredOptions;
+            let disposed = false;
+            let nextTurnNumber = 0;
+            const scenarioSession = {
+                async runTurn(message) {
+                    if (disposed)
+                        throw new Error('OpenCode Scenario V2 session is disposed');
+                    const sessionOptions = configuredOptions;
+                    sessionOptions?.getAbortSignal?.()?.throwIfAborted();
+                    await runtimePolicy.beforeTurn(sessionOptions?.getRemainingMs?.() ?? 0);
+                    try {
+                        sessionOptions?.getAbortSignal?.()?.throwIfAborted();
+                        return await coordinator.attachment.runTurn(message, ++nextTurnNumber);
+                    }
+                    finally {
+                        await runtimePolicy.afterTurn();
+                    }
+                },
+            };
+            const attachedCoordinator = coordinator;
+            return {
+                configureSession(sessionOptions) {
+                    if (disposed)
+                        throw new Error('OpenCode Scenario V2 runtime is disposed');
+                    if (configuredOptions && configuredOptions !== sessionOptions) {
+                        throw new Error('OpenCode Scenario V2 runtime is already configured for another session');
+                    }
+                    configuredOptions = sessionOptions;
+                    configuredSessions.set(sessionOptions, scenarioSession);
+                },
+                beginTurn: attachedCoordinator.beginTurn,
+                settleTurn: attachedCoordinator.settleTurn,
+                failTurn: attachedCoordinator.failTurn,
+                evidence: attachedCoordinator.evidence,
+                async dispose() {
+                    if (disposed)
+                        return;
+                    disposed = true;
+                    const failures = [];
+                    try {
+                        await attachedCoordinator.dispose();
+                    }
+                    catch (error) {
+                        failures.push(error);
+                    }
+                    if (configuredOptions)
+                        configuredSessions.delete(configuredOptions);
+                    try {
+                        await Promise.all(xdgDirectories.map((directory) => removeSandboxRoot(directory)));
+                    }
+                    catch (error) {
+                        failures.push(error);
+                    }
+                    if (failures.length > 0)
+                        throw new AggregateError(failures, 'OpenCode Scenario V2 cleanup failed');
+                },
+            };
+        }
+        catch (error) {
+            const cleanupErrors = [];
+            try {
+                await coordinator?.dispose();
+            }
+            catch (cleanupError) {
+                cleanupErrors.push(cleanupError);
+            }
+            try {
+                await Promise.all(xdgDirectories.map((directory) => removeSandboxRoot(directory)));
+            }
+            catch (cleanupError) {
+                cleanupErrors.push(cleanupError);
+            }
+            if (cleanupErrors.length > 0) {
+                throw new AggregateError([error, ...cleanupErrors], 'OpenCode Scenario V2 setup and cleanup failed');
+            }
+            throw error;
+        }
+    };
+}
+function definedEnvironment(environment) {
+    return Object.fromEntries(Object.entries(environment).filter((entry) => entry[1] !== undefined));
+}
+function isolatedOpenCodeDirectories(environment) {
+    if (!environment.HOME)
+        throw new Error('OpenCode Scenario V2 requires a managed HOME');
+    return [
+        path.join(environment.HOME, '.local', 'share'),
+        path.join(environment.HOME, '.config'),
+        path.join(environment.HOME, '.local', 'state'),
+        path.join(environment.HOME, '.cache'),
+    ];
+}
+function buildScenarioEnvironment(environment, runtimePolicy, directories) {
+    const [data, config, state, cache] = directories;
+    const result = {
+        ...environment,
+        XDG_DATA_HOME: data,
+        XDG_CONFIG_HOME: config,
+        XDG_STATE_HOME: state,
+        XDG_CACHE_HOME: cache,
+        ...runtimePolicy.environment(),
+        OPENCODE_PERMISSION,
+    };
+    delete result.OPENCODE_CONFIG_CONTENT;
+    return result;
+}
+async function assertNoProjectConfig(workspacePath) {
+    for (const name of ['opencode.json', 'opencode.jsonc', '.opencode']) {
+        if (await fs.pathExists(path.join(workspacePath, name))) {
+            throw new Error(`OpenCode workspace configuration is not allowed: ${name}`);
+        }
+    }
+}
+function scenarioToolNames(artifact) {
+    return new Set(Object.entries(artifact.canonicalIr.servers).flatMap(([serverId, server]) => Object.keys(server.tools).map((toolId) => `${sanitizeOpenCodeToolName(serverId)}_${sanitizeOpenCodeToolName(toolId)}`)));
+}
+function normalizeOpenCodeToolName(title, mcpToolNames) {
+    if (mcpToolNames.has(title))
+        return { action: 'mcp_tool_call', providerToolName: title };
+    const nativeActions = {
+        bash: 'run_shell', read: 'read_file', write: 'write_file', edit: 'edit_file',
+        grep: 'search_code', glob: 'list_files', list: 'list_files', skill: 'use_skill',
+        todowrite: 'update_todos', lsp: 'search_code',
+    };
+    const action = nativeActions[title.toLowerCase()];
+    return { action: action ?? 'unknown', providerToolName: title };
+}
+function scenarioScanRoots(workspacePath, environment, xdgDirectories) {
+    return [...new Set([
+            path.dirname(workspacePath),
+            workspacePath,
+            environment.HOME,
+            ...xdgDirectories,
+        ].filter((entry) => typeof entry === 'string' && entry.length > 0))];
+}

package/dist/agents/opencode.js

@@ -13,6 +13,7 @@ import { currentOpenCodePlatformKey, OPENCODE_RUNTIME_LOCK, } from './opencode/c
 import { OpenCodeRuntimePolicy, OPENCODE_PERMISSION } from './opencode/runtime-policy.js';
 import { killOpenCodeProcessGroup, registerOpenCodeProcessGroup, unregisterOpenCodeProcessGroup, } from './opencode/process-groups.js';
 import { assertCleanManagedOpenCodeHost, sha256File } from './opencode/host-safety.js';
+import { getOpenCodeScenarioSession } from './opencode/scenario.js';
 export { assertCleanManagedOpenCodeHost, managedOpenCodeConfigPaths } from './opencode/host-safety.js';
 const OUTPUT_CAP_BYTES = 16 * 1024 * 1024;
 const NATIVE_TOOL_ACTIONS = {
@@ -512,11 +513,60 @@ class OpenCodeSession {
         await this.cleanupState();
     }
 }
+class OpenCodeScenarioAgentSession {
+    scenario;
+    started = false;
+    running = false;
+    failed = false;
+    disposed = false;
+    constructor(scenario) {
+        this.scenario = scenario;
+    }
+    start({ message }) {
+        if (this.started)
+            return Promise.reject(new Error('OpenCode session has already started'));
+        this.started = true;
+        return this.execute(message);
+    }
+    reply({ message }) {
+        if (!this.started)
+            return Promise.reject(new Error('OpenCode session has not started'));
+        return this.execute(message);
+    }
+    async execute(message) {
+        if (this.disposed)
+            throw new Error('OpenCode session is disposed');
+        if (this.failed)
+            throw new Error('OpenCode session is unusable after a failed turn');
+        if (this.running)
+            throw new Error('OpenCode does not allow concurrent turns');
+        this.running = true;
+        try {
+            const result = await this.scenario.runTurn(message);
+            if (result.exitCode !== 0 && !/"stopReason"\s*:\s*"cancelled"/.test(result.rawOutput))
+                this.failed = true;
+            return result;
+        }
+        catch (error) {
+            this.failed = true;
+            throw error;
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async dispose() {
+        this.disposed = true;
+    }
+}
 export class OpenCodeAgent extends BaseAgent {
     async createSession(runtime, _runCommand, options = {}) {
         if (!options.opencodeExecutable) {
             throw new Error('OpenCode requires opencodeExecutable');
         }
+        const scenario = getOpenCodeScenarioSession(options);
+        if (scenario)
+            return new OpenCodeScenarioAgentSession(scenario);
         return new OpenCodeSession(runtime, options);
     }
 }

package/dist/internal/direct-mcp-v2/acp-author-projector.d.ts

@@ -0,0 +1,20 @@
+import type { AgentTurnResult } from '../../types.js';
+import { type ToolAction } from '../../tool-events.js';
+import type { ProviderId } from './types.js';
+import type { AcpPromptResult, JsonRpcMessage } from './acp-client.js';
+export declare const ACP_AUTHOR_TRACE_MAX_CHARS: number;
+export type AcpToolName = {
+    action: ToolAction;
+    providerToolName: string;
+};
+export type AcpToolNameNormalizer = (title: string) => AcpToolName;
+export type AcpAuthorProjectionInput = {
+    provider: Extract<ProviderId, 'cursor' | 'opencode'>;
+    terminal: AcpPromptResult;
+    notifications: readonly JsonRpcMessage[];
+    normalizeToolName(title: string): AcpToolName;
+    protectedValues?: readonly string[];
+    sensitiveValues?: readonly string[];
+    turnNumber?: number;
+};
+export declare function projectAcpAuthorTurn(input: AcpAuthorProjectionInput): AgentTurnResult;

package/dist/internal/direct-mcp-v2/acp-author-projector.js

@@ -0,0 +1,147 @@
+import { buildSummary } from '../../tool-events.js';
+import { sanitizePersistenceValue, sanitizeToolEventResult } from '../../tool-event-results.js';
+export const ACP_AUTHOR_TRACE_MAX_CHARS = 64 * 1024;
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function updateFromNotification(message) {
+    if (message.method !== 'session/update')
+        throw new Error('ACP author projector received a non-update notification');
+    const params = object(message.params);
+    const update = object(params?.update);
+    if (!update || typeof update.sessionUpdate !== 'string')
+        throw new Error('ACP session/update contained no typed update');
+    return update;
+}
+function toolUpdate(update, priorTitle) {
+    if (update.sessionUpdate !== 'tool_call' && update.sessionUpdate !== 'tool_call_update')
+        throw new Error('ACP update was not a tool update');
+    const title = typeof update.title === 'string' && update.title.length > 0 ? update.title : priorTitle;
+    if (!title)
+        throw new Error('ACP tool update contained no title');
+    const rawInput = update.rawInput === undefined ? undefined : object(update.rawInput);
+    if (update.rawInput !== undefined && !rawInput)
+        throw new Error('ACP tool update rawInput was not an object');
+    const rawOutput = update.rawOutput === undefined ? undefined : object(update.rawOutput);
+    if (update.rawOutput !== undefined && !rawOutput)
+        throw new Error('ACP tool update rawOutput was not an object');
+    const output = update.output ?? rawOutput?.output;
+    const error = update.error ?? rawOutput?.error;
+    return {
+        sessionUpdate: update.sessionUpdate,
+        title,
+        ...(typeof update.toolCallId === 'string' ? { toolCallId: update.toolCallId } : {}),
+        ...(typeof update.status === 'string' ? { status: update.status } : {}),
+        ...(rawInput ? { rawInput } : {}),
+        ...(output !== undefined ? { output } : {}),
+        ...(error !== undefined ? { error } : {}),
+    };
+}
+function textValue(value) {
+    if (value === undefined)
+        return undefined;
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}
+export function projectAcpAuthorTurn(input) {
+    const protectedValues = input.protectedValues ?? [];
+    const redactionValues = [...new Set([...protectedValues, ...(input.sensitiveValues ?? [])])];
+    const serialized = JSON.stringify({ terminal: input.terminal, notifications: input.notifications });
+    if (protectedValues.some((value) => value.length > 0 && serialized.includes(value))) {
+        throw new Error('ACP provider reflected a protected control-plane value');
+    }
+    const assistantChunks = [];
+    const toolEvents = [];
+    const trace = [];
+    const toolCalls = new Map();
+    let providerError = false;
+    for (const notification of input.notifications) {
+        const update = updateFromNotification(notification);
+        if (update.sessionUpdate === 'agent_message_chunk') {
+            const content = object(update.content);
+            const text = typeof update.text === 'string'
+                ? update.text
+                : typeof content?.text === 'string' ? content.text : undefined;
+            if (text === undefined)
+                throw new Error('ACP agent message chunk contained no text');
+            assistantChunks.push(text);
+            trace.push({ sessionUpdate: 'agent_message_chunk', text });
+            continue;
+        }
+        if (update.sessionUpdate === 'error') {
+            if (typeof update.message !== 'string' || update.message.length === 0)
+                throw new Error('ACP error update contained no message');
+            providerError = true;
+            trace.push({ sessionUpdate: 'error', message: update.message });
+            continue;
+        }
+        if (update.sessionUpdate !== 'tool_call' && update.sessionUpdate !== 'tool_call_update') {
+            trace.push({ sessionUpdate: update.sessionUpdate });
+            continue;
+        }
+        const toolCallId = typeof update.toolCallId === 'string' ? update.toolCallId : undefined;
+        const prior = toolCallId ? toolCalls.get(toolCallId) : undefined;
+        const current = toolUpdate(update, prior?.title);
+        if (prior && prior.title !== current.title)
+            throw new Error('ACP tool update changed title for one call');
+        const correlated = {
+            ...prior,
+            ...current,
+            ...(current.rawInput ?? prior?.rawInput ? { rawInput: current.rawInput ?? prior?.rawInput } : {}),
+        };
+        trace.push({
+            sessionUpdate: current.sessionUpdate,
+            title: current.title,
+            ...(current.status ? { status: current.status } : {}),
+            ...(current.rawInput ? { rawInput: current.rawInput } : {}),
+        });
+        if (current.status !== 'completed' && current.status !== 'failed') {
+            if (current.toolCallId)
+                toolCalls.set(current.toolCallId, correlated);
+            continue;
+        }
+        const terminalFingerprint = JSON.stringify({
+            status: correlated.status,
+            rawInput: correlated.rawInput,
+            output: correlated.output,
+            error: correlated.error,
+        });
+        if (prior?.terminalFingerprint !== undefined) {
+            if (prior.terminalFingerprint !== terminalFingerprint)
+                throw new Error('ACP tool call emitted conflicting terminal updates');
+            continue;
+        }
+        if (current.toolCallId)
+            toolCalls.set(current.toolCallId, { ...correlated, terminalFingerprint });
+        const normalized = input.normalizeToolName(correlated.title);
+        const resultText = textValue(correlated.status === 'completed' ? correlated.output : correlated.error);
+        toolEvents.push({
+            action: normalized.action,
+            provider: input.provider,
+            providerToolName: normalized.providerToolName,
+            ...(input.turnNumber !== undefined ? { turnNumber: input.turnNumber } : {}),
+            ...(correlated.rawInput ? { arguments: correlated.rawInput } : {}),
+            status: correlated.status === 'completed' ? 'completed' : 'error',
+            ...(resultText !== undefined ? { result: sanitizeToolEventResult({ content: resultText }, redactionValues) } : {}),
+            summary: buildSummary(normalized.action, normalized.providerToolName, correlated.rawInput),
+            confidence: normalized.action === 'unknown' ? 'low' : 'high',
+            rawSnippet: JSON.stringify(sanitizePersistenceValue({ title: normalized.providerToolName, status: correlated.status, rawInput: correlated.rawInput }, redactionValues)).slice(0, 2_000),
+        });
+    }
+    const assistantMessage = sanitizePersistenceValue(assistantChunks.join(''), redactionValues);
+    const rawTrace = JSON.stringify(sanitizePersistenceValue({
+        terminal: { stopReason: input.terminal.stopReason },
+        updates: trace,
+    }, redactionValues));
+    const traceOutput = rawTrace.length > ACP_AUTHOR_TRACE_MAX_CHARS
+        ? `${rawTrace.slice(0, ACP_AUTHOR_TRACE_MAX_CHARS - 1)}…`
+        : rawTrace;
+    return sanitizePersistenceValue({
+        rawOutput: traceOutput,
+        traceOutput,
+        assistantMessage,
+        visibleAssistantMessage: assistantMessage,
+        visibleAssistantMessageSource: 'assistant_message',
+        exitCode: input.terminal.stopReason === 'end_turn' && !providerError ? 0 : 1,
+        toolEvents,
+    }, redactionValues);
+}

package/dist/internal/direct-mcp-v2/acp-author-session.d.ts

@@ -0,0 +1,39 @@
+import type { AgentTurnResult } from '../../types.js';
+import { type RuntimeLock } from './runtime-lock.js';
+import { type AcpClient, type SpawnAcpClientOptions } from './acp-client.js';
+import { type AcpToolNameNormalizer } from './acp-author-projector.js';
+import type { JsonObject, ProviderId, ScenarioProviderAttachContext, ScenarioProviderAttachment } from './types.js';
+export type AcpAuthorSession = {
+    runTurn(message: string, turnNumber?: number): Promise<AgentTurnResult>;
+    interrupt(reason?: string): Promise<void>;
+    waitForTerminal(): Promise<void>;
+    close(): Promise<void>;
+};
+export type CreateAcpAuthorSessionOptions = {
+    provider: Extract<ProviderId, 'cursor' | 'opencode'>;
+    client: AcpClient;
+    mcpServers: readonly JsonObject[];
+    normalizeToolName: AcpToolNameNormalizer;
+    protectedValues?: readonly string[];
+    sensitiveValues?: readonly string[];
+    assertProtectedSurfacesClean?(): Promise<void>;
+    closeJoinTimeoutMs?: number;
+};
+export type AttachAcpAuthorSessionOptions = {
+    provider: Extract<ProviderId, 'cursor' | 'opencode'>;
+    context: ScenarioProviderAttachContext;
+    runtimeLock: RuntimeLock;
+    resolvedExecutable: string;
+    cwd: string;
+    environment: NodeJS.ProcessEnv;
+    scanRoots: readonly string[];
+    normalizeToolName: AcpToolNameNormalizer;
+    createClient?: (options: SpawnAcpClientOptions) => AcpClient;
+};
+export declare function createAcpAuthorSession(options: CreateAcpAuthorSessionOptions): Promise<AcpAuthorSession>;
+export declare function createAcpScenarioAttachment(session: AcpAuthorSession): ScenarioProviderAttachment<AcpAuthorSession>;
+/**
+ * P4/P5 provider seam: attach one exact, relocatable ACP runtime to the
+ * coordinator and return the reusable author session as its opaque value.
+ */
+export declare function attachAcpAuthorSession(options: AttachAcpAuthorSessionOptions): Promise<ScenarioProviderAttachment<AcpAuthorSession>>;