@wix/pathgrade 1.0.27 → 1.0.29

package/README.md

@@ -420,7 +420,7 @@ provider-specific scenario flags and profile controls are not public.
 ## CLI
 
 ```bash
-pathgrade run [--changed] [--since=<ref>] [--changed-files=<path>] [--adapter=<name|path>] [--diagnostics] [--verbose] [--quiet] [-- runner-args]
+pathgrade run [--changed] [--since=<ref>] [--changed-files=<path>] [--adapter=<name|path>] [--attempts=N] [--diagnostics] [--verbose] [--quiet] [-- runner-args]
 pathgrade init [--force]
 pathgrade validate <file.eval.ts>
 pathgrade validate --affected
@@ -434,6 +434,7 @@ pathgrade report [--results-path=<path>] [--no-comment] [--comment-id=<id>] [--d
 Useful details:
 
 - `pathgrade run --changed` computes affected evals first, writes selection metadata to `.pathgrade/selection.json`, and only then launches the selected runner adapter. Vitest is the default adapter; Jest is selected with `runner.adapter: 'jest'` or `--adapter=jest`.
+- `pathgrade run --attempts=3` reruns every selected case in three sequential, fresh runner processes. The CLI value overrides `attempts` in config; arguments after `--` still belong to the runner.
 - `pathgrade preview browser` starts a local viewer on `http://localhost:3847`.
 - `pathgrade report` posts or updates a PR comment in GitHub Actions; locally it prints the markdown report and then the numeric pass rate. Provider orchestrators can add a `--details-url`, suppress stale updates with `--expected-head-sha`, and opt into surfaced API failures with `--strict`.
 - `pathgrade validate --affected` is a strict mode for CI: every discovered eval must either live under a `SKILL.md` anchor or export valid `__pathgradeMeta`.
@@ -445,22 +446,20 @@ Run `pathgrade --help` for the full help text.
 ```typescript
 // pathgrade.config.ts
 export default {
-    runner: {
-        adapter: 'vitest',
-        args: [],
-    },
+    attempts: 1, // opt in to runner-owned repetitions
+    runner: { adapter: 'vitest', args: [] },
     evals: {
         include: ['**/*.eval.ts'],   // default
         exclude: ['**/fixtures/**'], // replaces the default exclude list if set
     },
-    affected: {
-        global: ['package.json', 'yarn.lock'],
-    },
+    affected: { global: ['package.json', 'yarn.lock'] },
     ci: { threshold: 0.8 },
 };
 ```
 
-Pathgrade reads `pathgrade.config.*` for CLI and affected-selection behavior. `runner.adapter` and `--adapter=<name|path>` select the runner; `--adapter` wins over config. Built-in adapters currently include `vitest`, `jest`, and the narrow `node-test` proof adapter.
+Pathgrade reads `pathgrade.config.*` for CLI and affected-selection behavior. `runner.adapter` and `--adapter=<name|path>` select the runner; `--adapter` wins over config. `attempts` defaults to `1` and must be a positive integer. Built-in adapters `vitest`, `jest`, and `node-test` support repeated attempts; third-party invocation adapters must advertise `supportsRepeatedAttempts: true` and produce the normalized child snapshot contract.
+
+New reports use schema version 2. They preserve every attempt with `case_id`, `attempt_id`, and `attempt_index`; include the display-safe `runner_outcome` that determined binary success; publish `mean_reward` for partial scores; and publish finite-sample pass@k only for complete binary attempts. Runner assertions, runner diagnostics, and native runner references remain in the normalized run model and are not copied into public report artifacts; evaluation diagnostics retain their existing report behavior. A partial reward or incomplete attempt makes pass@k explicitly unavailable. Version-1 reports remain readable, but Pathgrade no longer computes pass@k or pass^k by pooling heterogeneous cases.
 
 Third-party runner adapters are supported through `@wix/pathgrade/adapter-kit`. Adapter names resolve as follows:
 
@@ -561,18 +560,15 @@ jobs:
         with:
           node-version: '20'
       - run: npm ci
-
       - name: Run affected evals
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         run: npx pathgrade run --changed
-
       - name: Post PR report
         if: always()
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: npx pathgrade report
-
       - uses: actions/upload-artifact@v4
         if: always()
         with:
@@ -589,16 +585,13 @@ See the [User Guide - CI Integration](docs/USER_GUIDE.md#ci-integration) for the
 ## Links
 
 - [User Guide](docs/USER_GUIDE.md) - full API reference and usage patterns
-- Examples:
-  - [start-chat](examples/start-chat/) - multi-turn conversation
-  - [sdk-showcase](examples/sdk-showcase/) - advanced SDK features in one suite
-  - [tool-judge-demo](examples/tool-judge-demo/) - `judge({ tools })` reading workspace artifacts
+- [start-chat](examples/start-chat/) - multi-turn conversation
+- [sdk-showcase](examples/sdk-showcase/) - advanced SDK features in one suite
+- [tool-judge-demo](examples/tool-judge-demo/) - `judge({ tools })` reading workspace artifacts
 
 ## Note on AI provider dependencies
 
-Pathgrade is released under the MIT license. Pathgrade can use third-party AI agent tools and SDKs to run evaluations, including `@anthropic-ai/claude-agent-sdk` for Claude, Codex CLI for Codex, and `cursor-agent` for Cursor. These tools, SDKs, hosted services, and related authentication methods are governed by their respective provider terms, which are separate from Pathgrade's MIT license.
-
-In particular, `@anthropic-ai/claude-agent-sdk` is governed by Anthropic's Commercial Terms of Service, except where Anthropic specifies a different license for a specific component or dependency.
+Pathgrade is released under the MIT license. It can use third-party AI agent tools and SDKs, including `@anthropic-ai/claude-agent-sdk`, Codex CLI, and `cursor-agent`. Those tools, services, and authentication methods have separate provider terms; in particular, the Claude Agent SDK is governed by Anthropic's Commercial Terms unless Anthropic specifies another license for a component.
 
 ## License
 

package/dist/adapters/jest/invocation-adapter.js

@@ -9,6 +9,8 @@ export function createJestInvocationAdapter(input) {
     const spawnJest = input.spawnJest ?? defaultSpawnJest;
     return {
         name: 'jest',
+        supportsRepeatedAttempts: true,
+        writeEmptyReport: false,
         async run(runInput) {
             const selection = await readSidecarForInvocation(runInput.cwd, runInput.env.PATHGRADE_SELECTION_INVOCATION_ID, msg => {
                 process.stderr.write(`[pathgrade] ${msg}\n`);
@@ -36,7 +38,8 @@ export function createJestInvocationAdapter(input) {
                         },
                         runnerArgs: [],
                         env: runInput.env,
-                        artifactRoot: getPathgradeDir(runInput.cwd),
+                        artifactRoot: runInput.env.PATHGRADE_ARTIFACT_ROOT ?? getPathgradeDir(runInput.cwd),
+                        normalizedSnapshotPath: runInput.env.PATHGRADE_NORMALIZED_SNAPSHOT_PATH,
                         reporterMode: input.config.reporter ?? 'cli',
                         threshold: input.config.ci.threshold,
                         selection,
@@ -69,6 +72,7 @@ export function createJestInvocationAdapter(input) {
                     '--reporters',
                     resolveReporterFile(),
                     ...runInput.runnerArgs,
+                    '--testLocationInResults',
                 ],
             });
         },

package/dist/adapters/jest/reporter.js

@@ -4,12 +4,14 @@ import { fmt, getPathgradeDir, printReportSummary, readSidecarForInvocation, res
 import { getJestLifecycleMetadata } from './lifecycle.js';
 import { readJestMetadata, removeJestMetadata } from './metadata.js';
 import { createJestAdapter } from './runner-adapter.js';
+import { assertDirectReporterAttemptsSupported } from '../../runners/direct-reporter-attempts.js';
 export default class PathgradeJestReporter {
     async onRunComplete(_contexts, results) {
         const cwd = process.cwd();
         const config = await resolvePathgradeConfig({ cwd });
+        assertDirectReporterAttemptsSupported(config.attempts, process.env);
         const mode = config.reporter ?? 'cli';
-        const outputDir = getPathgradeDir(cwd);
+        const outputDir = process.env.PATHGRADE_ARTIFACT_ROOT ?? getPathgradeDir(cwd);
         const metadataByCaseId = new Map([
             ...readJestMetadata(),
             ...getJestLifecycleMetadata(),
@@ -25,6 +27,7 @@ export default class PathgradeJestReporter {
                 runnerArgs: [],
                 env: process.env,
                 artifactRoot: outputDir,
+                normalizedSnapshotPath: process.env.PATHGRADE_NORMALIZED_SNAPSHOT_PATH,
                 reporterMode: mode,
                 threshold: config.ci.threshold,
                 writeEmptyReport: false,

package/dist/adapters/jest/results.js

@@ -34,6 +34,7 @@ export function normalizeJestRunResults(input) {
                     runId,
                     unitId: unitId(fileIndex),
                     caseId,
+                    repeatKey: jestRepeatKey(fileResult.testFilePath, assertion.fullName ?? fullCaseName(assertion), assertion.location),
                     assertion,
                     filePath: fileResult.testFilePath,
                     evaluations: input.metadataByCaseId?.get(caseId) ?? [],
@@ -71,6 +72,7 @@ function runCase(input) {
     const failureMessage = input.assertion.failureMessages?.find(message => message.trim().length > 0);
     return {
         id: input.caseId,
+        repeatKey: input.repeatKey,
         runId: input.runId,
         unitId: input.unitId,
         name: fullCaseName(input.assertion),
@@ -110,6 +112,12 @@ function runCase(input) {
             }],
     };
 }
+function jestRepeatKey(filePath, fullName, location) {
+    return JSON.stringify([
+        'jest', filePath.replaceAll('\\', '/'), fullName,
+        location?.line ?? null, location?.column ?? null,
+    ]);
+}
 function fullCaseName(assertion) {
     const ancestors = assertion.ancestorTitles ?? [];
     return [...ancestors, assertion.title].filter(Boolean).join(' > ');

package/dist/adapters/node-test/index.d.ts

@@ -6,3 +6,8 @@ export declare function test(name: string, options: NodeTestOptions, fn: NodeTes
 export default test;
 export { createNodeTestAdapter } from './runner-adapter.js';
 export { createNodeTestInvocationAdapter } from './invocation-adapter.js';
+export declare function parseNodeTestCallerLocation(stack: string, cwd: string): {
+    sourceRef: string;
+    line?: number;
+    column?: number;
+} | undefined;

package/dist/adapters/node-test/index.js

@@ -11,8 +11,18 @@ export function test(name, optionsOrFn, maybeFn) {
     installResultCapture();
     const options = typeof optionsOrFn === 'function' ? undefined : optionsOrFn;
     const fn = typeof optionsOrFn === 'function' ? optionsOrFn : maybeFn;
-    const sourceRef = callerSourceRef();
+    const source = callerSource();
+    const sourceRef = source.sourceRef;
     const caseId = `${sourceRef}:${name}:${++caseCounter}`;
+    const repeatKey = JSON.stringify([
+        'node-test', sourceRef, source.line ?? null, source.column ?? null, name,
+    ]);
+    if (options?.skip === true || typeof options?.skip === 'string') {
+        writeCase({
+            caseId, repeatKey, name, state: 'skipped', runnerDurationMs: 0,
+            sourceRef, filePath: sourceRef, groupName: sourceRef, runnerCaseId: caseId,
+        });
+    }
     nodeTest(name, options, async (ctx) => {
         const startedAt = performance.now();
         let state = 'passed';
@@ -37,6 +47,7 @@ export function test(name, optionsOrFn, maybeFn) {
             const evaluations = await lifecycle.flushCase(caseId);
             writeCase({
                 caseId,
+                repeatKey,
                 name,
                 state,
                 runnerDurationMs: performance.now() - startedAt,
@@ -87,18 +98,35 @@ function writeCase(testCase) {
     existing.push(testCase);
     fs.writeFileSync(resultsPath, `${JSON.stringify(existing, null, 2)}\n`);
 }
-function callerSourceRef() {
+function callerSource() {
     const stack = new Error().stack ?? '';
     const cwd = realpath(process.env.PATHGRADE_NODE_TEST_CWD ?? process.cwd());
+    return parseNodeTestCallerLocation(stack, cwd) ?? { sourceRef: 'node-test' };
+}
+export function parseNodeTestCallerLocation(stack, cwd) {
     for (const line of stack.split('\n')) {
-        const match = line.match(/\(?((?:file:\/\/)?[^() ]+\.eval\.[cm]?[jt]s)(?::\d+)?(?::\d+)?\)?/);
-        if (!match)
+        const location = line.match(/:(\d+):(\d+)\)?\s*$/);
+        if (!location || location.index === undefined)
+            continue;
+        const prefix = line.slice(0, location.index);
+        const extension = prefix.match(/\.eval\.[cm]?[jt]s$/);
+        if (!extension)
             continue;
-        const raw = match[1];
+        const fileUrlStart = prefix.indexOf('file://');
+        const cwdStart = prefix.indexOf(cwd);
+        const wrapperStart = prefix.indexOf('(');
+        const start = fileUrlStart >= 0 ? fileUrlStart
+            : cwdStart >= 0 ? cwdStart
+                : wrapperStart >= 0 ? wrapperStart + 1
+                    : prefix.lastIndexOf('at ') + 3;
+        const raw = prefix.slice(Math.max(0, start));
         const abs = realpath(raw.startsWith('file://') ? fileURLToPath(raw) : raw);
-        return path.relative(cwd, abs).replaceAll(path.sep, '/');
+        return {
+            sourceRef: path.relative(cwd, abs).replaceAll(path.sep, '/'),
+            line: Number(location[1]),
+            column: Number(location[2]),
+        };
     }
-    return 'node-test';
 }
 function realpath(value) {
     try {

package/dist/adapters/node-test/invocation-adapter.js

@@ -6,6 +6,7 @@ import { createNodeTestAdapter } from './runner-adapter.js';
 export function createNodeTestInvocationAdapter(input) {
     return {
         name: 'node-test',
+        supportsRepeatedAttempts: true,
         async run(runInput) {
             const selection = await readSidecarForInvocation(runInput.cwd, runInput.env.PATHGRADE_SELECTION_INVOCATION_ID, msg => {
                 process.stderr.write(`[pathgrade] ${msg}\n`);
@@ -24,7 +25,8 @@ export function createNodeTestInvocationAdapter(input) {
                     },
                     runnerArgs: runInput.runnerArgs,
                     env: runInput.env,
-                    artifactRoot: getPathgradeDir(runInput.cwd),
+                    artifactRoot: runInput.env.PATHGRADE_ARTIFACT_ROOT ?? getPathgradeDir(runInput.cwd),
+                    normalizedSnapshotPath: runInput.env.PATHGRADE_NORMALIZED_SNAPSHOT_PATH,
                     reporterMode: input.config.reporter ?? 'cli',
                     threshold: input.config.ci.threshold,
                     selection,

package/dist/adapters/node-test/runner-adapter.js

@@ -37,7 +37,7 @@ export function createNodeTestAdapter() {
                     adapterName: this.name,
                     status: 'completed',
                     exitCode: 0,
-                    native: { resultsPath },
+                    native: { resultsPath, resultsDir },
                 };
             }
             const exitCode = await spawnNodeTest({
@@ -54,23 +54,29 @@ export function createNodeTestAdapter() {
                 adapterName: this.name,
                 status: input.signal?.aborted ? 'cancelled' : (exitCode === 0 ? 'completed' : 'failed'),
                 exitCode,
-                native: { resultsPath },
+                native: { resultsPath, resultsDir },
             };
         },
         async collectNormalizedRunSnapshot(run) {
             const native = readNodeTestRunNative(run);
-            const cases = await readCases(native.resultsPath);
-            const groupMap = new Map();
-            for (const testCase of cases) {
-                const groupName = testCase.groupName ?? testCase.filePath ?? testCase.sourceRef ?? 'node-test';
-                if (!groupMap.has(groupName))
-                    groupMap.set(groupName, []);
-                groupMap.get(groupName).push(testCase);
+            try {
+                const cases = await readCases(native.resultsPath);
+                const groupMap = new Map();
+                for (const testCase of cases) {
+                    const groupName = testCase.groupName ?? testCase.filePath ?? testCase.sourceRef ?? 'node-test';
+                    if (!groupMap.has(groupName))
+                        groupMap.set(groupName, []);
+                    groupMap.get(groupName).push(testCase);
+                }
+                return buildNormalizedRunSnapshotFromReportGroups(run, Array.from(groupMap.entries()).map(([groupName, groupedCases]) => ({
+                    groupName,
+                    cases: groupedCases,
+                })));
+            }
+            finally {
+                if (native.resultsDir)
+                    await fs.remove(native.resultsDir);
             }
-            return buildNormalizedRunSnapshotFromReportGroups(run, Array.from(groupMap.entries()).map(([groupName, groupedCases]) => ({
-                groupName,
-                cases: groupedCases,
-            })));
         },
     };
 }
@@ -96,10 +102,11 @@ async function spawnNodeTest(input) {
 function readNodeTestRunNative(run) {
     if (typeof run.native === 'object'
         && run.native !== null
-        && typeof run.native.resultsPath === 'string') {
+        && typeof run.native.resultsPath === 'string'
+        && typeof run.native.resultsDir === 'string') {
         return run.native;
     }
-    return { resultsPath: '' };
+    return { resultsPath: '', resultsDir: '' };
 }
 async function readCases(resultsPath) {
     if (!resultsPath || !(await fs.pathExists(resultsPath)))

package/dist/adapters/vitest/reporter.js

@@ -7,6 +7,7 @@ import { printReportSummary } from '../../reporters/report-summary.js';
 import { createVitestAdapter } from '../../runners/vitest-adapter.js';
 import { runWithAdapter } from '../../runners/orchestrator.js';
 import { resolvePathgradeConfig } from '../../config/pathgrade.js';
+import { assertDirectReporterAttemptsSupported } from '../../runners/direct-reporter-attempts.js';
 /**
  * Custom vitest reporter that layers pathgrade aggregate statistics
  * on top of vitest's default output.
@@ -19,8 +20,9 @@ export class PathgradeReporter {
     async onTestRunEnd(testModules) {
         const cwd = process.cwd();
         const config = await resolvePathgradeConfig({ cwd });
+        assertDirectReporterAttemptsSupported(config.attempts, process.env);
         const mode = this.opts.reporter ?? config.reporter ?? 'cli';
-        const outputDir = getPathgradeDir(cwd);
+        const outputDir = process.env.PATHGRADE_ARTIFACT_ROOT ?? getPathgradeDir(cwd);
         const adapter = createVitestAdapter({ testModules });
         const exitCode = await runWithAdapter({
             adapter,
@@ -30,6 +32,7 @@ export class PathgradeReporter {
                 runnerArgs: [],
                 env: process.env,
                 artifactRoot: outputDir,
+                normalizedSnapshotPath: process.env.PATHGRADE_NORMALIZED_SNAPSHOT_PATH,
                 reporterMode: mode,
                 threshold: this.opts.ci?.threshold ?? config.ci.threshold,
                 writeEmptyReport: false,

package/dist/agents/claude.js

@@ -88,10 +88,11 @@ export class ClaudeAgent extends BaseAgent {
             hostEnv,
             sandboxProfile: this.deps.sandboxProfile,
         });
-        const claudeCodeExecutable = resolveClaudeCodeExecutable({
-            agentOptionsExecutable: this.opts.claudeCodeExecutable,
-            envExecutable,
-        });
+        const claudeCodeExecutable = sessionOptions?.admittedClaudeCodeExecutable
+            ?? resolveClaudeCodeExecutable({
+                agentOptionsExecutable: this.opts.claudeCodeExecutable,
+                envExecutable,
+            });
         const mcpMountOptions = {
             workspacePath,
             mcpConfigPath: sessionOptions?.mcpConfigPath,

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

@@ -16,58 +16,8 @@ import { projectItemIntoTurn } from './item-projection.js';
 import { CodexItemLifecycle, } from './item-lifecycle.js';
 import { createCodexManagedAuth } from './managed-auth.js';
 import { clearTurnAuthorityDeadline, closeUncorrelatedTurnTransport, establishAuthoritativeTurn, isAbortError, isAuthoritativeTurnCompletion, rememberAuthoritativeTurnId, shouldRetireAuthoritativeTurnTransport, } from './turn-authority.js';
+import { dispatchCodexNotification, failTurn } from './turn-notifications.js';
 const TURN_COMPLETED_METHOD = 'turn/completed';
-function projectMcpStartupStatusIntoTurn(params, turn) {
-    const name = params.name ?? 'unknown';
-    const status = params.status ?? 'unknown';
-    const error = typeof params.error === 'string' ? params.error : undefined;
-    turn.nonAskToolEvents.push({
-        action: 'unknown',
-        provider: 'codex',
-        providerToolName: 'mcpServer/startupStatus/updated',
-        turnNumber: turn.turnNumber,
-        arguments: {
-            name,
-            status,
-            ...(error ? { error } : {}),
-        },
-        summary: `MCP server ${name} startup ${status}`,
-        confidence: 'high',
-        rawSnippet: JSON.stringify(params),
-    });
-    if (status === 'failed') {
-        const message = `MCP server ${name} failed to start${error ? `: ${error}` : ''}`;
-        failTurn(turn, message);
-    }
-}
-function dispatchCodexNotification(notification, turn, sensitiveValues) {
-    if (process.env.PATHGRADE_CODEX_DEBUG) {
-        const debugParams = sanitizePersistenceValue(notification.params, sensitiveValues);
-        console.error(`[codex app-server] notification method=${notification.method} params=${JSON.stringify(debugParams).slice(0, 300)}`);
-    }
-    if (notification.method === 'mcpServer/startupStatus/updated') {
-        if (turn) {
-            projectMcpStartupStatusIntoTurn((notification.params ?? {}), turn);
-        }
-        return;
-    }
-    if (!turn)
-        return;
-    const params = notification.params;
-    if (notification.method === 'item/started') {
-        if (params)
-            turn.itemLifecycle?.receiveStarted(params);
-        return;
-    }
-    if (notification.method === 'item/completed' && params) {
-        turn.itemLifecycle?.receiveCompleted(params);
-    }
-}
-function failTurn(turn, message) {
-    turn.turnFailed = true;
-    turn.failureMessage = message;
-    turn.signalFailure?.(message);
-}
 function recordFromUnknown(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value

package/dist/agents/codex-app-server/turn-notifications.d.ts

@@ -0,0 +1,6 @@
+import type { ActiveTurnState } from './turn-state.js';
+export declare function dispatchCodexNotification(notification: {
+    method: string;
+    params: unknown;
+}, turn: ActiveTurnState | null, sensitiveValues: readonly string[]): void;
+export declare function failTurn(turn: ActiveTurnState, message: string): void;

package/dist/agents/codex-app-server/turn-notifications.js

@@ -0,0 +1,51 @@
+import { sanitizePersistenceValue } from '../../tool-event-results.js';
+export function dispatchCodexNotification(notification, turn, sensitiveValues) {
+    if (process.env.PATHGRADE_CODEX_DEBUG) {
+        const debugParams = sanitizePersistenceValue(notification.params, sensitiveValues);
+        console.error(`[codex app-server] notification method=${notification.method} params=${JSON.stringify(debugParams).slice(0, 300)}`);
+    }
+    if (notification.method === 'mcpServer/startupStatus/updated') {
+        if (turn) {
+            projectMcpStartupStatusIntoTurn((notification.params ?? {}), turn);
+        }
+        return;
+    }
+    if (!turn)
+        return;
+    const params = notification.params;
+    if (notification.method === 'item/started') {
+        if (params)
+            turn.itemLifecycle?.receiveStarted(params);
+        return;
+    }
+    if (notification.method === 'item/completed' && params) {
+        turn.itemLifecycle?.receiveCompleted(params);
+    }
+}
+export function failTurn(turn, message) {
+    turn.turnFailed = true;
+    turn.failureMessage = message;
+    turn.signalFailure?.(message);
+}
+function projectMcpStartupStatusIntoTurn(params, turn) {
+    const name = params.name ?? 'unknown';
+    const status = params.status ?? 'unknown';
+    const error = typeof params.error === 'string' ? params.error : undefined;
+    turn.nonAskToolEvents.push({
+        action: 'unknown',
+        provider: 'codex',
+        providerToolName: 'mcpServer/startupStatus/updated',
+        turnNumber: turn.turnNumber,
+        arguments: {
+            name,
+            status,
+            ...(error ? { error } : {}),
+        },
+        summary: `MCP server ${name} startup ${status}`,
+        confidence: 'high',
+        rawSnippet: JSON.stringify(params),
+    });
+    if (status === 'failed') {
+        failTurn(turn, `MCP server ${name} failed to start${error ? `: ${error}` : ''}`);
+    }
+}

package/dist/agents/codex-app-server/turn-state.d.ts

@@ -0,0 +1,19 @@
+import type { ToolEvent } from '../../tool-events.js';
+import type { PendingMcpDenial } from './mcp-approval-correlator.js';
+import type { CodexItemLifecycle } from './item-lifecycle.js';
+export interface ActiveTurnState {
+    turnNumber: number;
+    askBatchIds: string[];
+    nonAskToolEvents: ToolEvent[];
+    pendingMcpDenials: PendingMcpDenial[];
+    itemLifecycle?: CodexItemLifecycle;
+    assistantMessageParts: string[];
+    turnFailed: boolean;
+    failureMessage?: string;
+    signalFailure?: (message: string) => void;
+    authoritativeThreadId?: string;
+    authoritativeTurnId?: string;
+    pendingTurnCompletions: unknown[];
+    acceptTurnCompletion?: (params: unknown) => void;
+    authorityDeadlineTimer?: ReturnType<typeof setTimeout>;
+}

package/dist/agents/codex-app-server/turn-state.js

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

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

@@ -0,0 +1,7 @@
+import type { ToolAction } from '../../tool-events.js';
+export declare const NATIVE_TOOL_ACTIONS: Readonly<Record<string, ToolAction>>;
+export declare const ALLOWED_EVENT_TYPES: ReadonlySet<string>;
+export declare function protocolRecord(value: unknown, label: string): Record<string, unknown>;
+export declare function protocolFiniteNumber(value: unknown, label: string): number;
+export declare function protocolRequiredString(value: unknown, label: string): string;
+export declare function sanitizedProviderError(event: Record<string, unknown>): Error;

package/dist/agents/opencode/protocol.js

@@ -0,0 +1,47 @@
+export const NATIVE_TOOL_ACTIONS = {
+    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',
+};
+export const ALLOWED_EVENT_TYPES = new Set([
+    'tool_use',
+    'step_start',
+    'step_finish',
+    'text',
+    'reasoning',
+    'error',
+]);
+export function protocolRecord(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`OpenCode protocol error: ${label} must be an object`);
+    }
+    return value;
+}
+export function protocolFiniteNumber(value, label) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        throw new Error(`OpenCode protocol error: ${label} must be a nonnegative finite number`);
+    }
+    return value;
+}
+export function protocolRequiredString(value, label) {
+    if (typeof value !== 'string' || !value) {
+        throw new Error(`OpenCode protocol error: ${label} must be a nonempty string`);
+    }
+    return value;
+}
+export function sanitizedProviderError(event) {
+    const error = protocolRecord(event.error, 'error');
+    const data = error.data && typeof error.data === 'object' && !Array.isArray(error.data)
+        ? error.data
+        : {};
+    const status = typeof data.statusCode === 'number' ? ` status=${data.statusCode}` : '';
+    const retryable = typeof data.isRetryable === 'boolean' ? ` retryable=${data.isRetryable}` : '';
+    return new Error(`OpenCode provider error${status}${retryable}`);
+}

package/dist/agents/opencode.js

@@ -14,28 +14,9 @@ import { OpenCodeRuntimePolicy, OPENCODE_PERMISSION } from './opencode/runtime-p
 import { killOpenCodeProcessGroup, registerOpenCodeProcessGroup, unregisterOpenCodeProcessGroup, } from './opencode/process-groups.js';
 import { assertCleanManagedOpenCodeHost, sha256File } from './opencode/host-safety.js';
 import { getOpenCodeScenarioSession } from './opencode/scenario.js';
+import { ALLOWED_EVENT_TYPES, NATIVE_TOOL_ACTIONS, protocolFiniteNumber as finiteNumber, protocolRecord as record, protocolRequiredString as requiredString, sanitizedProviderError, } from './opencode/protocol.js';
 export { assertCleanManagedOpenCodeHost, managedOpenCodeConfigPaths } from './opencode/host-safety.js';
 const OUTPUT_CAP_BYTES = 16 * 1024 * 1024;
-const NATIVE_TOOL_ACTIONS = {
-    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 ALLOWED_EVENT_TYPES = new Set([
-    'tool_use',
-    'step_start',
-    'step_finish',
-    'text',
-    'reasoning',
-    'error',
-]);
 export function spawnOpenCode(executable, args, options) {
     return new Promise((resolve, reject) => {
         const stdout = [];
@@ -124,33 +105,6 @@ export function spawnOpenCode(executable, args, options) {
         }
     });
 }
-function record(value, label) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error(`OpenCode protocol error: ${label} must be an object`);
-    }
-    return value;
-}
-function finiteNumber(value, label) {
-    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
-        throw new Error(`OpenCode protocol error: ${label} must be a nonnegative finite number`);
-    }
-    return value;
-}
-function requiredString(value, label) {
-    if (typeof value !== 'string' || !value) {
-        throw new Error(`OpenCode protocol error: ${label} must be a nonempty string`);
-    }
-    return value;
-}
-function sanitizedProviderError(event) {
-    const error = record(event.error, 'error');
-    const data = error.data && typeof error.data === 'object' && !Array.isArray(error.data)
-        ? error.data
-        : {};
-    const status = typeof data.statusCode === 'number' ? ` status=${data.statusCode}` : '';
-    const retryable = typeof data.isRetryable === 'boolean' ? ` retryable=${data.isRetryable}` : '';
-    return new Error(`OpenCode provider error${status}${retryable}`);
-}
 export function parseOpenCodeOutput(stdout, processResult, mcpToolNames, sensitiveValues = []) {
     if (processResult.overflow)
         throw new Error('OpenCode output exceeded the 16 MiB limit');