@wix/pathgrade 1.0.25 → 1.0.27

package/dist/sdk/managed-session.js

@@ -10,6 +10,8 @@ import { attachTurnResultSensitiveValues, cloneTurnResultWithSensitiveValues, ge
 import { attachToolEventSensitiveValues, getToolEventSensitiveValues } from './tool-event-secrets.js';
 import { sanitizePersistenceValue } from '../tool-event-results.js';
 import { startScriptedMcpMockHost, } from '../providers/scripted-mcp-mock-host.js';
+import { startPublicClaudeScenarioRuntime, } from '../internal/direct-mcp-v2/public-scenario-runtime.js';
+import { TrialExecutionError } from '../internal/direct-mcp-v2/cleanup.js';
 export function createManagedSession(deps) {
     const { ws, agentName, timeoutSec, messages, log, model, conversationWindow, llm } = deps;
     const agentTimeoutMs = timeoutSec * 1000;
@@ -40,9 +42,12 @@ export function createManagedSession(deps) {
     let setupDone = false;
     let currentSignal;
     let scriptedHost;
+    let scenarioRuntime;
     let activeTurn = false;
     let nextTurnNumber = 0;
     let disposePromise;
+    let primaryTurnError;
+    let inFlightTurn;
     const runCommand = async (cmd) => {
         const result = await ws.exec(cmd, { signal: currentSignal });
         log.push(sanitizePersistenceValue({
@@ -62,67 +67,145 @@ export function createManagedSession(deps) {
         if (remaining <= 0)
             throw new Error(`${label} timed out`);
         activeTurn = true;
+        let finishTurnJoin;
+        const turnJoin = new Promise((resolve) => { finishTurnJoin = resolve; });
+        inFlightTurn = turnJoin;
         try {
             return await withAbortTimeout(async (signal) => {
-                currentSignal = signal;
-                if (!session) {
-                    // Run auth setup commands before first agent turn
-                    if (!setupDone) {
-                        for (const cmd of ws.setupCommands) {
-                            await ws.exec(cmd, { signal });
-                            signal.throwIfAborted();
+                try {
+                    currentSignal = signal;
+                    if (!session) {
+                        // Run auth setup commands before first agent turn
+                        if (!setupDone) {
+                            for (const cmd of ws.setupCommands) {
+                                await ws.exec(cmd, { signal });
+                                signal.throwIfAborted();
+                            }
+                            setupDone = true;
+                        }
+                        // Carry the workspace's resolved env (from `prepareWorkspace
+                        // → resolveCredentials`) into the runtime handle so drivers
+                        // that auth through `Options.env` (notably the Claude SDK
+                        // driver) can lift Anthropic keys out. Drivers that only
+                        // need the workspace path keep using `getWorkspacePath`.
+                        const runtime = {
+                            handle: ws.path,
+                            workspacePath: ws.path,
+                            env: ws.env,
+                        };
+                        if (deps.scriptedMcp) {
+                            scriptedHost = await startScriptedMcpMockHost(deps.scriptedMcp);
+                            sessionOptions.scriptedMcpHost = scriptedHost;
+                        }
+                        if (deps.scenarioArtifact) {
+                            const startScenarioRuntime = deps.scenarioRuntimeFactory ?? startPublicClaudeScenarioRuntime;
+                            scenarioRuntime = await startScenarioRuntime({
+                                artifact: deps.scenarioArtifact,
+                                workspacePath: ws.path,
+                                environment: ws.env,
+                                onEvidence: deps.onScenarioEvidence,
+                            });
+                            try {
+                                scenarioRuntime.configureSession(sessionOptions);
+                            }
+                            catch (error) {
+                                try {
+                                    await scenarioRuntime.dispose();
+                                }
+                                catch (cleanupError) {
+                                    throw new AggregateError([error, cleanupError], 'Scenario provider projection failed and coordinator cleanup also failed');
+                                }
+                                scenarioRuntime = undefined;
+                                throw error;
+                            }
+                        }
+                        try {
+                            session = await createAgentSession(agent, runtime, runCommand, sessionOptions);
+                        }
+                        catch (error) {
+                            try {
+                                await scriptedHost?.dispose();
+                                await scenarioRuntime?.dispose();
+                            }
+                            catch (cleanupError) {
+                                throw new AggregateError([error, cleanupError], 'Agent session setup failed and scenario cleanup also failed');
+                            }
+                            scriptedHost = undefined;
+                            scenarioRuntime = undefined;
+                            throw error;
                         }
-                        setupDone = true;
-                    }
-                    // Carry the workspace's resolved env (from `prepareWorkspace
-                    // → resolveCredentials`) into the runtime handle so drivers
-                    // that auth through `Options.env` (notably the Claude SDK
-                    // driver) can lift Anthropic keys out. Drivers that only
-                    // need the workspace path keep using `getWorkspacePath`.
-                    const runtime = {
-                        handle: ws.path,
-                        workspacePath: ws.path,
-                        env: ws.env,
-                    };
-                    if (deps.scriptedMcp) {
-                        scriptedHost = await startScriptedMcpMockHost(deps.scriptedMcp);
-                        sessionOptions.scriptedMcpHost = scriptedHost;
                     }
+                    const turnNumber = ++nextTurnNumber;
+                    scriptedHost?.beginTurn(turnNumber);
+                    scenarioRuntime?.beginTurn(`turn-${turnNumber}`, signal);
+                    let result;
                     try {
-                        session = await createAgentSession(agent, runtime, runCommand, sessionOptions);
+                        result = turnNumber === 1
+                            ? await session.start({ message })
+                            : await session.reply({ message });
                     }
                     catch (error) {
-                        await scriptedHost?.dispose();
-                        scriptedHost = undefined;
+                        try {
+                            await scenarioRuntime?.failTurn(error);
+                        }
+                        catch (lifecycleError) {
+                            if (lifecycleError instanceof TrialExecutionError) {
+                                primaryTurnError = lifecycleError;
+                                throw lifecycleError;
+                            }
+                            const combined = new AggregateError([error, lifecycleError], 'Provider turn failed and scenario settlement also failed');
+                            primaryTurnError = combined;
+                            throw combined;
+                        }
+                        primaryTurnError = error;
                         throw error;
                     }
-                }
-                const turnNumber = ++nextTurnNumber;
-                scriptedHost?.beginTurn(turnNumber);
-                let result = turnNumber === 1
-                    ? await session.start({ message })
-                    : await session.reply({ message });
-                if (scriptedHost) {
-                    const settled = scriptedHost.settleEvents(result.toolEvents);
-                    result.toolEvents = settled.events;
-                    if (settled.error) {
-                        result = cloneTurnResultWithSensitiveValues(result, {
-                            exitCode: 1,
-                            rawOutput: settled.error.message,
-                        });
+                    if (result.exitCode !== 0 || result.timedOut) {
+                        const providerTerminalError = new Error(`Provider terminal: exit ${result.exitCode}`);
+                        primaryTurnError = providerTerminalError;
+                        try {
+                            await scenarioRuntime?.failTurn(providerTerminalError);
+                        }
+                        catch (lifecycleError) {
+                            if (lifecycleError instanceof TrialExecutionError) {
+                                primaryTurnError = lifecycleError;
+                                throw lifecycleError;
+                            }
+                            const combined = new AggregateError([providerTerminalError, lifecycleError], 'Provider terminal failed and scenario settlement also failed');
+                            primaryTurnError = combined;
+                            throw combined;
+                        }
+                    }
+                    else {
+                        await scenarioRuntime?.settleTurn();
+                    }
+                    if (scriptedHost) {
+                        const settled = scriptedHost.settleEvents(result.toolEvents);
+                        result.toolEvents = settled.events;
+                        if (settled.error) {
+                            result = cloneTurnResultWithSensitiveValues(result, {
+                                exitCode: 1,
+                                rawOutput: settled.error.message,
+                            });
+                        }
+                    }
+                    const sensitiveValues = [...new Set([
+                            ...(deps.sensitiveValues ?? []),
+                            ...getTurnResultSensitiveValues(result),
+                        ])];
+                    for (const event of result.toolEvents) {
+                        attachToolEventSensitiveValues(event, [...new Set([
+                                ...sensitiveValues,
+                                ...getToolEventSensitiveValues(event),
+                            ])]);
                     }
+                    return attachTurnResultSensitiveValues(result, sensitiveValues);
                 }
-                const sensitiveValues = [...new Set([
-                        ...(deps.sensitiveValues ?? []),
-                        ...getTurnResultSensitiveValues(result),
-                    ])];
-                for (const event of result.toolEvents) {
-                    attachToolEventSensitiveValues(event, [...new Set([
-                            ...sensitiveValues,
-                            ...getToolEventSensitiveValues(event),
-                        ])]);
+                finally {
+                    finishTurnJoin();
+                    if (inFlightTurn === turnJoin)
+                        inFlightTurn = undefined;
                 }
-                return attachTurnResultSensitiveValues(result, sensitiveValues);
             }, remaining, label);
         }
         finally {
@@ -166,12 +249,36 @@ export function createManagedSession(deps) {
             if (disposePromise)
                 return disposePromise;
             disposePromise = (async () => {
+                const cleanupErrors = [];
                 try {
                     await session?.dispose?.();
                 }
-                finally {
+                catch (error) {
+                    cleanupErrors.push(error);
+                }
+                if (inFlightTurn) {
+                    try {
+                        await withAbortTimeout(async () => inFlightTurn, Math.min(agentTimeoutMs, 2_000), 'Agent turn cleanup');
+                    }
+                    catch (error) {
+                        cleanupErrors.push(error);
+                    }
+                }
+                try {
                     await scriptedHost?.dispose();
                 }
+                catch (error) {
+                    cleanupErrors.push(error);
+                }
+                try {
+                    await scenarioRuntime?.dispose();
+                }
+                catch (error) {
+                    cleanupErrors.push(error);
+                }
+                if (cleanupErrors.length > 0) {
+                    throw new AggregateError(primaryTurnError === undefined ? cleanupErrors : [primaryTurnError, ...cleanupErrors], primaryTurnError === undefined ? 'Agent session cleanup failed' : 'Provider turn failed and cleanup also failed');
+                }
             })();
             return disposePromise;
         },

package/dist/sdk/scenario-evidence.d.ts

@@ -0,0 +1,27 @@
+import type { EvidenceEnvelope } from '../internal/direct-mcp-v2/types.js';
+export type ExpectedScenarioCaseMatch = {
+    caseId?: string;
+    serverId?: string;
+    toolId?: string;
+    turnId?: string;
+};
+export type ScenarioCaseMatchEvidence = {
+    trialId: string;
+    turnId: string;
+    invocationId: string;
+    serverId: string;
+    toolId: string;
+    caseId: string;
+    stateBefore: string;
+};
+export type ScenarioStateTransitionEvidence = ScenarioCaseMatchEvidence & {
+    stateAfter: string;
+    committedEpoch: number;
+};
+export declare class ScenarioEvidenceError extends Error {
+    constructor(message: string);
+}
+export declare function findScenarioCaseMatches(evidence: readonly EvidenceEnvelope[], expected?: ExpectedScenarioCaseMatch): ScenarioCaseMatchEvidence[];
+export declare function wasScenarioCaseMatched(evidence: readonly EvidenceEnvelope[], expected: ExpectedScenarioCaseMatch): boolean;
+export declare function getScenarioStateTimeline(evidence: readonly EvidenceEnvelope[]): ScenarioStateTransitionEvidence[];
+export declare function getFinalScenarioState(evidence: readonly EvidenceEnvelope[]): string;

package/dist/sdk/scenario-evidence.js

@@ -0,0 +1,94 @@
+import { verifyEvidenceChain } from '../internal/direct-mcp-v2/evidence.js';
+export class ScenarioEvidenceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ScenarioEvidenceError';
+    }
+}
+export function findScenarioCaseMatches(evidence, expected = {}) {
+    const invocations = canonicalInvocations(evidence);
+    const matches = [];
+    for (const envelope of evidence) {
+        const decision = envelope.payload;
+        if (decision.type !== 'mcp.decision' || decision.outcome !== 'matched' || !decision.caseId)
+            continue;
+        const invocation = invocations.get(decision.invocationId);
+        if (!invocation)
+            throw new ScenarioEvidenceError(`matched decision references unknown invocation ${decision.invocationId}`);
+        const match = { ...invocation, caseId: decision.caseId };
+        if (matchesExpectedCase(match, expected))
+            matches.push(match);
+    }
+    return matches;
+}
+export function wasScenarioCaseMatched(evidence, expected) {
+    return findScenarioCaseMatches(evidence, expected).length > 0;
+}
+export function getScenarioStateTimeline(evidence) {
+    const matches = new Map(findScenarioCaseMatches(evidence).map((entry) => [entry.invocationId, entry]));
+    const timeline = [];
+    for (const envelope of evidence) {
+        const commit = envelope.payload;
+        if (commit.type !== 'mcp.commit')
+            continue;
+        const match = matches.get(commit.invocationId);
+        if (!match)
+            throw new ScenarioEvidenceError(`commit references unmatched invocation ${commit.invocationId}`);
+        if (match.stateBefore !== commit.stateBefore) {
+            throw new ScenarioEvidenceError(`commit state disagrees with invocation ${commit.invocationId}`);
+        }
+        timeline.push({
+            ...match,
+            stateAfter: commit.stateAfter,
+            committedEpoch: commit.committedEpoch,
+        });
+    }
+    return timeline;
+}
+export function getFinalScenarioState(evidence) {
+    assertCanonicalEvidence(evidence);
+    const payload = evidence.at(-1)?.payload;
+    if (payload?.type === 'turn.finalized' && payload.state !== undefined)
+        return payload.state;
+    throw new ScenarioEvidenceError('canonical evidence does not end with a finalized scenario state');
+}
+function canonicalInvocations(evidence) {
+    assertCanonicalEvidence(evidence);
+    const invocations = new Map();
+    for (const envelope of evidence) {
+        const invocation = envelope.payload;
+        if (invocation.type !== 'mcp.invocation')
+            continue;
+        if (invocations.has(invocation.invocationId)) {
+            throw new ScenarioEvidenceError(`duplicate invocation ${invocation.invocationId}`);
+        }
+        invocations.set(invocation.invocationId, {
+            trialId: envelope.trialId,
+            turnId: envelope.turnId,
+            invocationId: invocation.invocationId,
+            serverId: invocation.serverId,
+            toolId: invocation.toolId,
+            stateBefore: invocation.stateBefore,
+        });
+    }
+    return invocations;
+}
+function assertCanonicalEvidence(evidence) {
+    const first = evidence[0];
+    if (!first)
+        throw new ScenarioEvidenceError('canonical evidence is empty');
+    const chain = verifyEvidenceChain(evidence, first.artifactDigest);
+    if (!chain.ok)
+        throw new ScenarioEvidenceError(`canonical evidence chain failed at index ${chain.index}: ${chain.reason}`);
+    for (const [index, envelope] of evidence.entries()) {
+        if (envelope.trialId !== first.trialId) {
+            throw new ScenarioEvidenceError(`canonical evidence changes trialId at index ${index}`);
+        }
+    }
+}
+function matchesExpectedCase(match, expected) {
+    return (expected.caseId === undefined || match.caseId === expected.caseId)
+        && (expected.serverId === undefined || match.serverId === expected.serverId)
+        && (expected.toolId === undefined || match.toolId === expected.toolId)
+        && (expected.turnId === undefined || match.turnId === expected.turnId);
+}

package/dist/sdk/scenario-machine-v2.d.ts

@@ -0,0 +1,9 @@
+import type { CompileScenarioResult } from '../internal/direct-mcp-v2/compiler.js';
+import type { ScenarioMachineV2 as InternalScenarioMachineV2 } from '../internal/direct-mcp-v2/types.js';
+/** Compile the public V2 source contract, whose concurrency safety policy is fixed by the version. */
+export declare function compileScenario(source: unknown): CompileScenarioResult;
+/** Compile strict JSON text using the public V2 source contract. */
+export declare function compileScenarioText(text: string): CompileScenarioResult;
+export type { CompileScenarioResult } from '../internal/direct-mcp-v2/compiler.js';
+export type ScenarioMachineV2 = Pick<InternalScenarioMachineV2, 'version' | 'scenarioId' | 'initialState' | 'servers' | 'states'>;
+export type { EvidenceEnvelope, JsonObject, JsonPrimitive, JsonValue, MatchExpr, MatchPredicate, McpContent, ScenarioArtifact, ScenarioCase, ScenarioDiagnostic, ScenarioEvidence, ScenarioRejection, ScenarioSuccess, ScenarioToolError, } from '../internal/direct-mcp-v2/types.js';

package/dist/sdk/scenario-machine-v2.js

@@ -0,0 +1,37 @@
+import { compileScenario as compileInternalScenario } from '../internal/direct-mcp-v2/compiler.js';
+import { canonicalJson, parseStrictJson } from '../internal/direct-mcp-v2/json.js';
+const V2_CONCURRENCY_POLICY = 'poison-effectful-overlap';
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Compile the public V2 source contract, whose concurrency safety policy is fixed by the version. */
+export function compileScenario(source) {
+    try {
+        canonicalJson(source);
+    }
+    catch (error) {
+        return { ok: false, diagnostics: [{ code: 'INVALID_JSON_VALUE', path: '$', message: error instanceof Error ? error.message : String(error) }] };
+    }
+    if (!object(source))
+        return compileInternalScenario(source);
+    const suppliedConcurrency = Object.prototype.hasOwnProperty.call(source, 'concurrency');
+    const compiled = compileInternalScenario({ ...source, concurrency: V2_CONCURRENCY_POLICY });
+    if (!suppliedConcurrency)
+        return compiled;
+    const diagnostic = { code: 'UNKNOWN_FIELD', path: '$/concurrency', message: 'unknown field concurrency' };
+    if (compiled.ok)
+        return { ok: false, diagnostics: [diagnostic] };
+    return {
+        ok: false,
+        diagnostics: [...compiled.diagnostics, diagnostic].sort((left, right) => canonicalJson(left).localeCompare(canonicalJson(right), 'en')),
+    };
+}
+/** Compile strict JSON text using the public V2 source contract. */
+export function compileScenarioText(text) {
+    try {
+        return compileScenario(parseStrictJson(text));
+    }
+    catch (error) {
+        return { ok: false, diagnostics: [{ code: 'INVALID_JSON_TEXT', path: '$', message: error instanceof Error ? error.message : String(error) }] };
+    }
+}

package/dist/sdk/snapshots.d.ts

@@ -1,6 +1,7 @@
 import type { LogEntry } from '../types.js';
 import type { ToolEvent } from '../tool-events.js';
 import type { AgentName, ConversationResult, Message, TurnTiming } from './types.js';
+import type { EvidenceEnvelope } from '../internal/direct-mcp-v2/types.js';
 export declare const RUN_SNAPSHOT_VERSION = 2;
 export interface RunSnapshot {
     version: 1 | 2;
@@ -17,6 +18,7 @@ export interface RunSnapshot {
         turnTimings: TurnTiming[];
     };
     workspace: string | null;
+    scenarioEvidence?: readonly EvidenceEnvelope[];
 }
 export declare function buildRunSnapshot(params: {
     agent: AgentName;
@@ -26,6 +28,7 @@ export declare function buildRunSnapshot(params: {
     workspace: string | null;
     timestamp?: string;
     sensitiveValues?: readonly string[];
+    scenarioEvidence?: readonly EvidenceEnvelope[];
 }): RunSnapshot;
 export declare class SnapshotParseError extends Error {
     constructor(message: string, options?: {

package/dist/sdk/snapshots.js

@@ -20,6 +20,7 @@ export function buildRunSnapshot(params) {
             turnTimings: [...conversationResult.turnTimings],
         },
         workspace,
+        ...(params.scenarioEvidence ? { scenarioEvidence: structuredClone(params.scenarioEvidence) } : {}),
     }, params.sensitiveValues);
 }
 export class SnapshotParseError extends Error {
@@ -153,5 +154,6 @@ function validateRunSnapshot(input) {
             turnTimings: snapshot.conversationResult.turnTimings,
         },
         workspace: typeof snapshot.workspace === 'string' ? snapshot.workspace : null,
+        scenarioEvidence: Array.isArray(snapshot.scenarioEvidence) ? snapshot.scenarioEvidence : [],
     };
 }

package/dist/sdk/types.d.ts

@@ -6,15 +6,19 @@ import type { DiagnosticsReport } from './diagnostics.js';
 import type { LLMPort } from '../utils/llm-types.js';
 import type { McpSafetyOptions } from './mcp-safety.js';
 import type { McpMockApprovalRule } from './mcp-mock-approvals.js';
+import type { EvidenceEnvelope } from '../internal/direct-mcp-v2/types.js';
+import type { ScenarioMachineV2 } from './scenario-machine-v2.js';
 export type AgentName = 'claude' | 'codex' | 'cursor' | 'opencode';
 export type AgentInteractionMode = 'prompt' | 'start_chat' | 'conversation';
 /** Runtime channel that actually executed the agent. */
-export type AgentExecutionTransport = AgentTransport | 'claude-agent-sdk' | 'cursor-agent';
+export type AgentExecutionTransport = AgentTransport | 'claude-agent-sdk' | 'cursor-agent' | 'acp';
 /** Privacy-safe execution dimensions exposed to result observers. */
 export interface AgentExecutionMetadata {
     name: AgentName;
     /** Model override requested by the caller; not necessarily the provider-resolved model. */
     requestedModel?: string;
+    /** Concrete model observed or selected for the executed turn. */
+    resolvedModel?: string;
     transport?: AgentExecutionTransport;
     interactionMode?: AgentInteractionMode;
 }
@@ -29,6 +33,8 @@ export interface AgentOptions {
     copyFromHome?: string[];
     env?: Record<string, string>;
     mcpMock?: MockMcpServerDescriptor | MockMcpServerDescriptor[];
+    /** Host-authoritative direct MCP scenario for explicit Claude, Codex app-server, OpenCode, and admitted Cursor runtimes. */
+    mcpScenario?: ScenarioMachineV2;
     /** Ordered, persistent simulated-user decisions for approval-required generated MCP tools. */
     mcpMockApprovalRules?: McpMockApprovalRule[];
     mcpConfigFile?: string;
@@ -85,6 +91,8 @@ export interface Agent {
     readonly workspace: string;
     /** Provider/runtime metadata only; never contains prompts or paths. */
     readonly executionMetadata?: AgentExecutionMetadata;
+    /** Immutable canonical ScenarioMachineV2 evidence. Pathgrade agents return an empty array when no scenario is configured. */
+    readonly scenarioEvidence?: readonly EvidenceEnvelope[];
     dispose(): Promise<void>;
 }
 export interface ConverseOptions {
@@ -337,6 +345,8 @@ export interface ScorerContext {
     toolEvents: import('../tool-events.js').ToolEvent[];
     runCommand: (cmd: string) => Promise<CommandResult>;
     artifacts: SessionArtifacts;
+    /** Canonical host evidence for ScenarioMachineV2 scorers. */
+    scenarioEvidence?: readonly EvidenceEnvelope[];
 }
 export interface EvaluateOptions {
     failFast?: boolean;

package/dist/tool-event-results.d.ts

@@ -1,6 +1,6 @@
 import type { ToolEventResult } from './tool-events.js';
 export declare const TOOL_RESULT_MAX_CHARS: number;
-export declare function collectSensitiveEnvValues(env?: Readonly<Record<string, string>>): string[];
+export declare function collectSensitiveEnvValues(env?: Readonly<Record<string, string | undefined>>): string[];
 /**
  * Clone a persistence payload while removing secrets from both structured
  * containers and any other strings that repeat their values. The second pass

package/dist/tool-event-results.js

@@ -41,6 +41,7 @@ const NON_SECRET_ENVIRONMENT_KEY_NAMES = new Set(['tokencount', 'tokenizersparal
 const BOUNDARY_ONLY_SENSITIVE_VALUE_MAX_LENGTH = 1;
 export function collectSensitiveEnvValues(env) {
     return [...new Set(Object.entries(env ?? {})
+            .filter((entry) => typeof entry[1] === 'string')
             .filter(([key, value]) => isSecretEnvironmentKey(key) && value.length > 0)
             .map(([, value]) => value))]
         .sort((a, b) => b.length - a.length);
@@ -153,7 +154,7 @@ function redactCredentialShapes(value, sensitiveValues, explicitSensitiveValues)
         redacted = redacted.replace(/([a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:)[^\s/@]+(@)/gi, '$1<redacted>$2');
     }
     if (redacted.includes('=') || redacted.includes(':')) {
-        redacted = redacted.replace(/(\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret|password|passwd|session(?:id)?|cookie)\s*[=:]\s*)[^\s,;"'}]+/gi, '$1<redacted>');
+        redacted = redacted.replace(/(\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret|token|secret|auth|password|passwd|session(?:id)?|cookie)\s*[=:]\s*)[^\s,;"'}]+/gi, '$1<redacted>');
     }
     return redacted;
 }

package/dist/tool-events.d.ts

@@ -64,6 +64,11 @@ export declare function extractToolEventsFromLog(log: ReadonlyArray<{
     type: string;
     tool_event?: ToolEvent;
 }>): ToolEvent[];
+/** Count shell commands across legacy command logs and provider tool events. */
+export declare function countShellCommandsFromLog(log: ReadonlyArray<{
+    type: string;
+    tool_event?: ToolEvent;
+}>): number;
 /**
  * Extract deduplicated skill names from tool events that have action 'use_skill'.
  */

package/dist/tool-events.js

@@ -101,6 +101,11 @@ export function extractToolEventsFromLog(log) {
         .filter((e) => e.type === 'tool_event' && e.tool_event != null)
         .map((e) => e.tool_event);
 }
+/** Count shell commands across legacy command logs and provider tool events. */
+export function countShellCommandsFromLog(log) {
+    return log.filter((entry) => entry.type === 'command'
+        || (entry.type === 'tool_event' && entry.tool_event?.action === 'run_shell')).length;
+}
 /**
  * Extract deduplicated skill names from tool events that have action 'use_skill'.
  */

package/dist/types.d.ts

@@ -175,6 +175,8 @@ export interface TrialResult {
      */
     total_cost_usd?: number;
     session_log: LogEntry[];
+    /** Redacted canonical ScenarioMachineV2 evidence for offline scoring and audit. */
+    scenario_evidence?: readonly import('./internal/direct-mcp-v2/types.js').EvidenceEnvelope[];
     skills_used?: string[];
     diagnostics?: DiagnosticsReport;
     result_kind?: import('./sdk/types.js').EvaluationResultKind;
@@ -289,6 +291,8 @@ export interface AgentTurnResult {
     timedOut?: boolean;
     toolEvents: import('./tool-events.js').ToolEvent[];
     runtimePoliciesApplied?: RuntimePolicyDescriptor[];
+    /** Concrete model that executed this turn, as resolved by the provider or runner. */
+    resolvedModel?: string;
     inputTokens?: number;
     outputTokens?: number;
     /**
@@ -390,6 +394,10 @@ export interface AgentSessionOptions {
     opencodeMcpToolNames?: string[];
     /** Managed-session-owned runtime for scripted generated MCP. */
     scriptedMcpHost?: import('./providers/scripted-mcp-mock-host.js').ScriptedMcpMockHost;
+    /** Parent-owned public ScenarioMachineV2 bridge; never serialized into child config. */
+    scenarioMcpServers?: Record<string, import('@anthropic-ai/claude-agent-sdk').McpSdkServerConfigWithInstance>;
+    /** Parent-owned admitted Codex app-server mount; projected only into thread/start memory. */
+    codexScenarioMount?: import('./agents/codex-app-server/scenario-mount.js').CodexScenarioMount;
     /** Runtime-only values inherited by drivers and persistence sinks for redaction. */
     sensitiveValues?: readonly string[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/pathgrade",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "packageManager": "yarn@4.12.0",
   "description": "Evaluate whether AI agents discover and use your skills correctly",
   "exports": {
@@ -140,5 +140,5 @@
     "typescript": "^5.9.3",
     "zod": "4.3.6"
   },
-  "falconPackageHash": "b936e0a54540b195856329c07c81e71818b9e4de30b90e768e9058d6"
+  "falconPackageHash": "5c7c088ce2f8c51308dde9f92d3f259465bbf34021afddb3af39d2d9"
 }