@workbench-ai/workbench-built-in-adapters 0.0.46 → 0.0.48

package/dist/agent-turn.d.ts

@@ -16,6 +16,7 @@ export interface WorkbenchAgentTurnRequest {
     cwd: string;
     prompt: string;
     traceRoot: string;
+    tracePath?: string;
     jobId: string;
     eventPublisher?: WorkbenchExecutionEventPublisher;
 }

package/dist/agent-turn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-turn.d.ts","sourceRoot":"","sources":["../src/agent-turn.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEV,mBAAmB,EACnB,YAAY,EACb,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAQL,KAAK,SAAS,EAEf,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EACV,gCAAgC,EACjC,MAAM,8BAA8B,CAAC;AAetC,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACxC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,SAAS,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,gCAAgC,CAAC;CACnD;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACpC,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,MAAM,0BAA0B,GAAG,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC,wBAAwB,CAAC,CAAC;AAoCnH,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC,wBAAwB,CAAC,EACnF,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,wBAAwB,CAAC,CAenC;AAED,wBAAsB,iCAAiC,CACrD,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,wBAAwB,CAAC,CA2FnC"}
+{"version":3,"file":"agent-turn.d.ts","sourceRoot":"","sources":["../src/agent-turn.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEV,mBAAmB,EACnB,YAAY,EACb,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAQL,KAAK,SAAS,EAEf,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EACV,gCAAgC,EACjC,MAAM,8BAA8B,CAAC;AAetC,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACxC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,SAAS,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,gCAAgC,CAAC;CACnD;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACpC,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,MAAM,0BAA0B,GAAG,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC,wBAAwB,CAAC,CAAC;AA4BnH,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC,wBAAwB,CAAC,EACnF,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,wBAAwB,CAAC,CAenC;AAED,wBAAsB,iCAAiC,CACrD,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,wBAAwB,CAAC,CAwFnC"}

package/dist/agent-turn.js

@@ -8,7 +8,7 @@ import { importWorkbenchRuntime } from "./runtime.js";
 const DEFAULT_AGENT_TURN_MAX_ATTEMPTS = 3;
 const DEFAULT_AGENT_TURN_RETRY_BASE_MS = 5_000;
 const DEFAULT_AGENT_TURN_RETRY_MAX_MS = 30_000;
-const AGENT_HARNESS_REGISTRY = {
+const AGENT_PROVIDER_REGISTRY = {
     codex: {
         executable: "codex",
         installHint: "@openai/codex",
@@ -32,14 +32,6 @@ const AGENT_HARNESS_REGISTRY = {
             return module.claudeCodeHarness();
         },
     },
-    pi: {
-        executable: "pi",
-        installHint: "@mariozechner/pi-coding-agent",
-        async load() {
-            const module = await import("@workbench-ai/agent-driver-badlogic-pi-coding-agent");
-            return module.piCodingAgentHarness();
-        },
-    },
 };
 export async function executeWorkbenchAgentTurn(executor, request) {
     const maxAttempts = workbenchAgentTurnMaxAttempts();
@@ -61,13 +53,13 @@ export async function executeWorkbenchAgentTurn(executor, request) {
 export async function defaultWorkbenchAgentTurnExecutor(request) {
     const execFileAsync = promisify(execFile);
     await ensureAgentExecutableOnPath(request.provider.use, execFileAsync);
-    const provider = await loadAgentHarnessProvider(request.provider.use);
+    const provider = await loadAgentProvider(request.provider.use);
     const agentHome = resolveRuntimeHome();
     const stageSessionPath = path.join(request.traceRoot, "session");
     await fs.mkdir(stageSessionPath, { recursive: true });
     const restoreEnv = applyAdapterAuthEnv(request.adapterAuthEnv);
     try {
-        const plan = await buildAgentHarnessExecutionPlan(provider, request.provider, request.workspaceRoot, agentHome, {
+        const plan = await buildAgentExecutionPlan(provider, request.provider, request.workspaceRoot, agentHome, {
             root: request.adapterAuthRoot,
             request: request.adapterAuthRequest,
         });
@@ -120,15 +112,9 @@ export async function defaultWorkbenchAgentTurnExecutor(request) {
             const usage = runtime.extractExecutionUsageFromTrace(turnResult.trace, request.provider, provider.manifest.id, turnResult.events);
             const eventCount = Math.max(turnResult.events.length, traceEventCount(turnResult.trace));
             await writeAgentTraceFile(path.join(stageSessionPath, "trace.json"), turnResult.trace);
-            await fs.writeFile(path.join(stageSessionPath, "agent-result.json"), `${JSON.stringify({
-                sessionId: turnResult.sessionId,
-                finalOutput: turnResult.finalOutput,
-                eventCount,
-                ...(usage ? { usage } : {}),
-            }, null, 2)}\n`);
             return {
                 output: turnResult.finalOutput,
-                traceFiles: await runtime.readOutputTraceFiles(request.traceRoot, `.workbench/traces/${request.jobId}/${request.role}`),
+                traceFiles: await runtime.readOutputTraceFiles(request.traceRoot, request.tracePath ?? `.workbench/traces/${request.jobId}/${request.role}`),
                 metadata: {
                     providerId: provider.manifest.id,
                     sessionId: turnResult.sessionId,
@@ -186,8 +172,8 @@ function traceEventCount(trace) {
         : {};
     return Array.isArray(traceRecord.events) ? traceRecord.events.length : 0;
 }
-async function loadAgentHarnessProvider(providerName) {
-    return await agentHarnessRegistration(providerName).load();
+async function loadAgentProvider(providerName) {
+    return await agentProviderRegistration(providerName).load();
 }
 async function ensureAgentExecutableOnPath(providerName, execFileAsync) {
     const executable = agentExecutableName(providerName);
@@ -202,28 +188,28 @@ async function ensureAgentExecutableOnPath(providerName, execFileAsync) {
     }
 }
 function agentExecutableName(providerName) {
-    return agentHarnessRegistration(providerName).executable;
+    return agentProviderRegistration(providerName).executable;
 }
 function agentExecutableInstallHint(providerName) {
-    return agentHarnessRegistration(providerName).installHint;
+    return agentProviderRegistration(providerName).installHint;
 }
-function agentHarnessRegistration(providerName) {
-    const registration = AGENT_HARNESS_REGISTRY[providerName];
+function agentProviderRegistration(providerName) {
+    const registration = AGENT_PROVIDER_REGISTRY[providerName];
     if (!registration) {
         throw new Error(`Unsupported first-party agent adapter: ${providerName}`);
     }
     return registration;
 }
-async function buildAgentHarnessExecutionPlan(provider, providerSpec, workspaceRoot, agentHome, adapterAuth) {
+async function buildAgentExecutionPlan(provider, providerSpec, workspaceRoot, agentHome, adapterAuth) {
     const turnTimeoutMs = provider.manifest.defaults.turn_timeout_ms ?? 3_600_000;
     const harness = {
         id: provider.manifest.id,
-        auth: await resolveAgentHarnessAuth(provider, providerSpec, workspaceRoot, agentHome, adapterAuth),
+        auth: await resolveAgentAuth(provider, providerSpec, workspaceRoot, agentHome, adapterAuth),
         ...(firstNonEmpty(providerSpec.model, provider.manifest.defaults.model) ? { model: firstNonEmpty(providerSpec.model, provider.manifest.defaults.model) } : {}),
         ...(firstNonEmpty(providerSpec.effort, provider.manifest.defaults.effort) ? { effort: firstNonEmpty(providerSpec.effort, provider.manifest.defaults.effort) } : {}),
         turn_timeout_ms: turnTimeoutMs,
         stall_timeout_ms: Math.max(provider.manifest.defaults.stall_timeout_ms ?? 0, turnTimeoutMs),
-        config: resolveAgentHarnessConfig(provider, defaultWorkbenchAgentHarnessConfig(provider, providerSpec.use)),
+        config: resolveAgentConfig(provider, defaultWorkbenchAgentConfig(provider, providerSpec.use)),
         retry: DEFAULT_HARNESS_RETRY,
         cancel: DEFAULT_HARNESS_CANCEL,
     };
@@ -235,15 +221,15 @@ async function buildAgentHarnessExecutionPlan(provider, providerSpec, workspaceR
         harness,
     };
 }
-function defaultWorkbenchAgentHarnessConfig(provider, providerName) {
+function defaultWorkbenchAgentConfig(provider, providerName) {
     const fallback = (provider.manifest.defaults.config ?? {});
     return {
         ...fallback,
-        ...(AGENT_HARNESS_REGISTRY[providerName]?.defaultConfig ?? {}),
+        ...(AGENT_PROVIDER_REGISTRY[providerName]?.defaultConfig ?? {}),
     };
 }
-async function resolveAgentHarnessAuth(provider, providerSpec, workspaceRoot, agentHome, adapterAuth) {
-    const subject = adapterAuthHarnessSubject(adapterAuth.request, providerSpec.use) ??
+async function resolveAgentAuth(provider, providerSpec, workspaceRoot, agentHome, adapterAuth) {
+    const subject = adapterAuthProviderSubject(adapterAuth.request, providerSpec.use) ??
         (provider.manifest.defaults.auth ?? {});
     const parsed = provider.schemas.auth.safeParse(subject);
     if (!parsed.success) {
@@ -253,7 +239,7 @@ async function resolveAgentHarnessAuth(provider, providerSpec, workspaceRoot, ag
     void agentHome;
     return { ...parsed.data };
 }
-function adapterAuthHarnessSubject(auth, providerName) {
+function adapterAuthProviderSubject(auth, providerName) {
     const record = jsonRecord(auth);
     const self = jsonRecord(record?.self);
     const adapters = jsonRecord(record?.adapters);
@@ -285,7 +271,7 @@ function adapterAuthHarnessSubject(auth, providerName) {
     }
     return null;
 }
-function resolveAgentHarnessConfig(provider, fallback) {
+function resolveAgentConfig(provider, fallback) {
     const parsed = provider.schemas.config.safeParse(fallback);
     if (!parsed.success) {
         throw new Error(`Agent provider "${provider.manifest.id}" config is invalid: ${formatValidationIssues(parsed.error.issues)}`);

package/dist/execute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../src/execute.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,IAAI,EAKL,MAAM,kCAAkC,CAAC;AAY1C,OAAO,KAAK,EAEV,0BAA0B,EAG3B,MAAM,iBAAiB,CAAC;AAQzB,MAAM,WAAW,4CAA4C;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,0BAA0B,CAAC;IAC3C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,IAAI,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AA4CD,wBAAsB,qCAAqC,CACzD,IAAI,GAAE,4CAAiD,GACtD,OAAO,CAAC,IAAI,CAAC,CAiEf"}
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../src/execute.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,IAAI,EAKL,MAAM,kCAAkC,CAAC;AAc1C,OAAO,KAAK,EAEV,0BAA0B,EAG3B,MAAM,iBAAiB,CAAC;AAQzB,MAAM,WAAW,4CAA4C;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,0BAA0B,CAAC;IAC3C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,IAAI,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AA4CD,wBAAsB,qCAAqC,CACzD,IAAI,GAAE,4CAAiD,GACtD,OAAO,CAAC,IAAI,CAAC,CAiEf"}

package/dist/execute.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { promises as fs } from "node:fs";
 import path from "node:path";
-import { ensureWorkbenchAdapterOutputDir, readWorkbenchAdapterOperationResult, readWorkbenchAdapterOperationRequest, writeWorkbenchAdapterOperationResult, workbenchAdapterOperationResultPath, } from "@workbench-ai/workbench-protocol";
+import { ensureWorkbenchAdapterOutputDir, readWorkbenchAdapterOperationResult, readWorkbenchAdapterOperationRequest, runWorkbenchRuntimeOperationSequence, writeWorkbenchAdapterOperationResult, workbenchAdapterOperationResultPath, } from "@workbench-ai/workbench-protocol";
 import YAML from "yaml";
 import { isWorkbenchBuiltInAdapterId, adapterCommandName, } from "./manifests.js";
 import { importWorkbenchRuntime } from "./runtime.js";
@@ -81,7 +81,7 @@ async function executeWorkbenchEngineRequest(request) {
 }
 async function executeWorkbenchEngineResolveRequest(request) {
     const configuredPath = workbenchEngineTasksPath(request);
-    const sourcePath = path.resolve(request.paths.cwd ?? request.paths.workspace, configuredPath);
+    const sourcePath = path.resolve(request.paths.workspace, configuredPath);
     const stat = await fs.stat(sourcePath).catch(() => null);
     if (!stat?.isDirectory()) {
         throw new Error(`Workbench engine tasks path is not a directory: ${sourcePath}`);
@@ -100,50 +100,42 @@ async function executeWorkbenchEngineResolveRequest(request) {
     });
 }
 async function executeWorkbenchEngineRunRequest(request) {
-    const enginePrivateFiles = await hideWorkbenchEnginePrivateFiles(request);
-    const subjectResult = await runSubjectFromWorkbenchEngine(request);
-    await stageWorkbenchEngineScoringInputs(request, enginePrivateFiles);
-    const score = workbenchEngineScoreInvocation(request);
-    await runNestedAdapterOperation({
-        parent: request,
-        invocation: score,
+    const outcome = workbenchEngineGradingIsolation(request) === "separate"
+        ? await runWorkbenchEngineSeparateGrading(request)
+        : await runWorkbenchEngineSharedGrading(request);
+    if (!outcome.result) {
+        throw new Error("Workbench engine scoring completed without an engine result.");
+    }
+    await writeSurfaceFiles(request.paths.output, outcome.files.map((file) => remapRuntimeControlTraceFile(request, file)));
+    const usage = await workbenchEngineOutcomeUsage(outcome);
+    await writeWorkbenchAdapterOperationResult(request.paths.output, {
+        protocol: "workbench.adapter-result.v1",
         operation: "engine.run",
-        command: score.command,
-        requestName: "score-request.json",
-    });
-    const engineResult = await readWorkbenchAdapterOperationResult(request.paths.output, "engine.run");
-    const usage = mergeNestedEngineUsage(subjectResult.usage, engineResult.usage);
-    if (usage) {
-        await writeWorkbenchAdapterOperationResult(request.paths.output, {
-            ...engineResult,
-            usage,
-        });
-    }
-}
-async function hideWorkbenchEnginePrivateFiles(request) {
-    if (!request.paths.enginePrivate) {
-        return [];
-    }
-    const files = await readSurfaceFilesRecursive(request.paths.enginePrivate).catch((error) => {
-        if (error.code === "ENOENT") {
-            return [];
-        }
-        throw error;
+        ok: true,
+        value: outcome.result,
+        ...(usage ? { usage } : {}),
+        ...(outcome.summary !== undefined ? { summary: outcome.summary } : {}),
+        ...(outcome.feedback !== undefined ? { feedback: outcome.feedback } : {}),
     });
-    await fs.rm(request.paths.enginePrivate, { recursive: true, force: true }).catch(() => undefined);
-    return files;
 }
-async function stageWorkbenchEngineScoringInputs(request, enginePrivateFiles) {
-    if (request.paths.enginePrivate) {
-        await fs.rm(request.paths.enginePrivate, { recursive: true, force: true }).catch(() => undefined);
-        await fs.mkdir(request.paths.enginePrivate, { recursive: true });
-        await writeSurfaceFiles(request.paths.enginePrivate, enginePrivateFiles);
-    }
-    if (request.paths.logs) {
-        const verifierLogs = path.join(request.paths.logs, "verifier");
-        await fs.rm(verifierLogs, { recursive: true, force: true }).catch(() => undefined);
-        await fs.mkdir(verifierLogs, { recursive: true });
-    }
+async function workbenchEngineOutcomeUsage(outcome) {
+    const runtime = await importWorkbenchRuntime();
+    const operationUsage = outcome.usage
+        ? undefined
+        : runtime.mergeUsageSummaries(outcome.operationResults.map((result) => {
+            if (result.operation === "subject.run") {
+                return runtime.assignUsageRole("runner", result.usage);
+            }
+            if (result.operation === "engine.run") {
+                return runtime.assignUsageRole("engine", result.usage);
+            }
+            return result.usage;
+        }));
+    const runtimeUsage = runtime.mergeUsageSummaries([outcome.usage, operationUsage]);
+    const resultUsage = runtimeUsage?.engine
+        ? undefined
+        : runtime.assignUsageRole("engine", outcome.result?.usage);
+    return runtime.mergeUsageSummaries([runtimeUsage, resultUsage]);
 }
 function workbenchEngineTasksPath(request) {
     const config = adapterCommandConfigRecord(request);
@@ -171,124 +163,145 @@ function workbenchEngineScoreInvocation(request) {
             : adapterCommandName(score.use),
     };
 }
-async function runSubjectFromWorkbenchEngine(request) {
+function workbenchEngineSubjectInvocation(request) {
     const subject = request.context?.subject?.run;
-    if (!subject?.command) {
-        throw new Error("engine.run request context.subject.run.command is required to invoke the subject.");
-    }
-    const subjectOutput = await runNestedAdapterOperation({
-        parent: request,
-        invocation: {
-            use: subject.use,
-            with: (subject.with ?? {}),
-            ...(subject.auth !== undefined ? { auth: subject.auth } : {}),
-            command: subject.command,
-        },
-        operation: "subject.run",
+    if (!subject?.use || !subject.command) {
+        throw new Error("Workbench engine requires context.subject.run.use and context.subject.run.command.");
+    }
+    return {
+        use: subject.use,
+        with: (subject.with ?? {}),
+        ...(subject.auth !== undefined ? { auth: subject.auth } : {}),
         command: subject.command,
-        requestName: "subject-request.json",
-        outputName: "subject-run",
-        visibility: "subject",
+    };
+}
+function workbenchEngineGradingIsolation(request) {
+    const grading = jsonRecord(adapterCommandConfigRecord(request).grading);
+    const isolation = grading?.isolation;
+    if (isolation === undefined) {
+        return "shared";
+    }
+    if (isolation === "shared" || isolation === "separate") {
+        return isolation;
+    }
+    throw new Error("Workbench engine grading.isolation must be shared or separate.");
+}
+async function runWorkbenchEngineSharedGrading(request) {
+    const inputs = await workbenchEngineRuntimeInputs(request);
+    const subject = workbenchEngineSubjectInvocation(request);
+    const score = workbenchEngineScoreInvocation(request);
+    const result = await runWorkbenchRuntimeOperationSequence({
+        inputs,
+        prepare: true,
+        operations: [
+            { label: "subject", operation: "subject.run", invocation: subject },
+            { label: "score", operation: "engine.run", invocation: score },
+        ],
     });
-    const result = await readWorkbenchAdapterOperationResult(subjectOutput, "subject.run");
-    await copySubjectOutputArtifacts(subjectOutput, request.paths.output);
+    assertRuntimeControlResultOk(result, "Workbench shared grading");
     return result;
 }
-function mergeNestedEngineUsage(subject, engine) {
-    const usage = {};
-    if (subject?.runner) {
-        usage.runner = subject.runner;
-    }
-    else if (subject?.total) {
-        usage.runner = subject.total;
-    }
-    if (engine?.engine) {
-        usage.engine = engine.engine;
-    }
-    else if (engine?.total) {
-        usage.engine = engine.total;
-    }
-    if (subject?.optimizer) {
-        usage.optimizer = subject.optimizer;
-    }
-    return Object.keys(usage).length > 0 ? usage : undefined;
-}
-async function runNestedAdapterOperation(args) {
-    const internalRoot = path.join(args.parent.paths.output, ".workbench", "internal", args.outputName ?? "engine-slot", safeInternalPathSegment(args.parent.id));
-    const output = args.outputName ? path.join(internalRoot, "output") : args.parent.paths.output;
-    const result = args.outputName
-        ? workbenchAdapterOperationResultPath(output)
-        : args.parent.paths.result;
-    const requestPath = path.join(internalRoot, args.requestName);
-    await fs.mkdir(path.dirname(requestPath), { recursive: true });
-    await fs.mkdir(output, { recursive: true });
-    const nestedPaths = {
-        ...args.parent.paths,
-        output,
-        result,
-    };
-    if (args.visibility === "subject") {
-        delete nestedPaths.enginePrivate;
-    }
-    await fs.writeFile(requestPath, `${JSON.stringify({
-        ...args.parent,
-        id: `${args.parent.id}:${args.invocation.use}:${args.operation}`,
-        operation: args.operation,
-        invocation: {
-            use: args.invocation.use,
-            with: args.invocation.with,
-            ...(args.invocation.auth !== undefined ? { auth: args.invocation.auth } : {}),
+async function runWorkbenchEngineSeparateGrading(request) {
+    const inputs = await workbenchEngineRuntimeInputs(request);
+    const subject = workbenchEngineSubjectInvocation(request);
+    const score = workbenchEngineScoreInvocation(request);
+    const runtime = await importWorkbenchRuntime();
+    const runner = await runWorkbenchRuntimeOperationSequence({
+        inputs: {
+            subject: inputs.subject,
+            case: inputs.case,
+            traces: inputs.traces,
         },
-        ...(args.parent.auth !== undefined
-            ? { auth: adapterScopedAuth(args.parent.auth, args.invocation.use) }
-            : {}),
-        paths: nestedPaths,
-    }, null, 2)}\n`);
-    await runAdapterShellCommand(args.command, args.parent.paths.cwd ?? args.parent.paths.workspace, {
-        WORKBENCH_ADAPTER_REQUEST: requestPath,
-        WORKBENCH_OUTPUT: output,
-        WORKBENCH_RESULT: result,
+        prepare: true,
+        collectWorkspace: true,
+        operations: [
+            { label: "subject", operation: "subject.run", invocation: subject },
+        ],
     });
-    return output;
+    assertRuntimeControlResultOk(runner, "Workbench separate runner");
+    const grader = await runWorkbenchRuntimeOperationSequence({
+        inputs: {
+            subject: inputs.subject,
+            case: inputs.case,
+            enginePrivate: inputs.enginePrivate,
+            traces: inputs.traces,
+            workspace: runner.workspaceFiles ?? [],
+            output: runner.files.filter((file) => !runtime.isWorkbenchInternalOutputPath(file.path)),
+        },
+        prepare: false,
+        operations: [
+            { label: "score", operation: "engine.run", invocation: score },
+        ],
+    });
+    assertRuntimeControlResultOk(grader, "Workbench separate grader");
+    return {
+        ...grader,
+        files: dedupeSurfaceFiles([...runner.files, ...grader.files]),
+        fileChanges: [...new Set([...runner.fileChanges, ...grader.fileChanges])].sort(),
+        usage: runtime.mergeUsageSummaries([runner.usage, grader.usage]),
+        operationResults: [...runner.operationResults, ...grader.operationResults],
+    };
 }
-async function copySubjectOutputArtifacts(source, target) {
-    await copyDirectoryEntries(source, target, "");
+async function workbenchEngineRuntimeInputs(request) {
+    const [subject, caseFiles, enginePrivate, traces] = await Promise.all([
+        readOptionalSurfaceFiles(request.paths.subject),
+        readOptionalSurfaceFiles(request.paths.case),
+        readOptionalSurfaceFiles(request.paths.enginePrivate),
+        readOptionalSurfaceFiles(request.paths.traces),
+    ]);
+    return {
+        subject,
+        case: caseFiles,
+        enginePrivate,
+        traces,
+    };
 }
-async function copyDirectoryEntries(sourceRoot, targetRoot, relativeDir) {
-    const sourceDir = path.join(sourceRoot, relativeDir);
-    const entries = await fs.readdir(sourceDir, { withFileTypes: true }).catch(() => []);
-    for (const entry of entries) {
-        const relativePath = path.join(relativeDir, entry.name);
-        const normalized = normalizeRelativePath(relativePath);
-        if (normalized === "workbench-result.json" || normalized.startsWith(".workbench/internal/")) {
-            continue;
-        }
-        const sourcePath = path.join(sourceRoot, relativePath);
-        const targetPath = path.join(targetRoot, relativePath);
-        if (entry.isDirectory()) {
-            await copyDirectoryEntries(sourceRoot, targetRoot, relativePath);
-            continue;
-        }
-        if (!entry.isFile()) {
-            continue;
+async function readOptionalSurfaceFiles(root) {
+    if (!root) {
+        return [];
+    }
+    return await readSurfaceFilesRecursive(root).catch((error) => {
+        if (error.code === "ENOENT") {
+            return [];
         }
-        await fs.mkdir(path.dirname(targetPath), { recursive: true });
-        await fs.copyFile(sourcePath, targetPath);
+        throw error;
+    });
+}
+function assertRuntimeControlResultOk(result, label) {
+    if (result.ok) {
+        return;
+    }
+    throw new Error(`${label} failed${result.error ? `: ${result.error}` : "."}`);
+}
+function dedupeSurfaceFiles(files) {
+    const byPath = new Map();
+    for (const file of files) {
+        const normalized = normalizeRelativePath(file.path);
+        byPath.set(normalized, {
+            ...file,
+            path: normalized,
+        });
     }
+    return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
-function adapterScopedAuth(auth, adapterId) {
-    if (!auth || typeof auth !== "object" || Array.isArray(auth)) {
-        return auth;
+function remapRuntimeControlTraceFile(request, file) {
+    const normalized = normalizeRelativePath(file.path);
+    if (!normalized.startsWith(".workbench/traces/")) {
+        return { ...file, path: normalized };
     }
-    const record = JSON.parse(JSON.stringify(auth));
-    const adapters = record.adapters;
-    if (adapters && typeof adapters === "object" && !Array.isArray(adapters)) {
-        const scoped = adapters[adapterId];
-        if (scoped !== undefined) {
-            record.self = scoped;
-        }
+    const segments = normalized.split("/");
+    const rest = segments.length >= 6
+        ? segments.slice(5)
+        : segments.length >= 3
+            ? segments.slice(3)
+            : [];
+    if (rest.length === 0) {
+        return { ...file, path: normalized };
     }
-    return record;
+    return {
+        ...file,
+        path: `.workbench/traces/${request.jobId ?? request.id}/${rest.join("/")}`,
+    };
 }
 function safeInternalPathSegment(value) {
     const safe = value.replace(/[^a-z0-9._-]+/giu, "_").replace(/^_+|_+$/gu, "");
@@ -296,7 +309,7 @@ function safeInternalPathSegment(value) {
 }
 async function executeCommandAdapterRequest(request) {
     const command = requiredAdapterCommandString(request, "command");
-    await runAdapterShellCommand(command, request.paths.cwd ?? request.paths.workspace);
+    await runAdapterShellCommand(command, request.paths.workspace);
     if (request.operation === "engine.run") {
         await requireCommandScoreResult(request);
         return;
@@ -316,9 +329,9 @@ async function executeTestsEngineRequest(request) {
         throw new Error(`Tests adapter cannot handle ${request.operation}.`);
     }
     const testsRoot = requiredRequestPath(request.paths.enginePrivate, "paths.enginePrivate");
-    const logsRoot = requiredRequestPath(request.paths.logs, "paths.logs");
-    const verifierLogs = path.join(logsRoot, "verifier");
-    await fs.mkdir(verifierLogs, { recursive: true });
+    const verifierRoot = testsVerifierOutputDir(request.paths.output);
+    await fs.rm(verifierRoot, { recursive: true, force: true }).catch(() => undefined);
+    await fs.mkdir(verifierRoot, { recursive: true });
     const script = await firstExistingFile([
         path.join(testsRoot, "test.sh"),
         path.join(testsRoot, "run.sh"),
@@ -326,9 +339,11 @@ async function executeTestsEngineRequest(request) {
     if (!script) {
         throw new Error(`Tests engine requires ${path.join(testsRoot, "test.sh")}.`);
     }
-    await runAdapterShellCommand(`sh ${shellQuote(script)}`, request.paths.cwd ?? request.paths.workspace);
+    await runAdapterShellCommand(`sh ${shellQuote(script)}`, request.paths.workspace, {
+        WORKBENCH_TESTS_VERIFIER_DIR: verifierRoot,
+    });
     const result = await readTestsResult({
-        logsRoot,
+        verifierRoot,
         caseId: request.context?.attempt?.caseId ?? "current",
     });
     await writeWorkbenchAdapterOperationResult(request.paths.output, {
@@ -371,7 +386,7 @@ async function writeOperationOkUnlessPresent(request) {
     if (request.operation === "optimizer.improve") {
         const patch = await createSubjectPatchFromWorkspace({
             beforeRoot: requiredRequestPath(request.paths.subject, "paths.subject"),
-            afterRoot: request.paths.cwd ?? request.paths.workspace,
+            afterRoot: request.paths.workspace,
             edits: request.context?.optimizer?.edits ?? [],
         });
         await writeWorkbenchAdapterOperationResult(request.paths.output, {
@@ -452,8 +467,8 @@ async function readWorkbenchEngineCase(args) {
     const publicPrefix = taskDirectoryPrefix(taskRecord.files, "files", args.id);
     const testsPrefix = taskDirectoryPrefix(taskRecord.tests, "tests", args.id);
     const solutionPrefix = taskDirectoryPrefix(taskRecord.solution, "solution", args.id);
-    const subjectVisible = stripTaskDirectory(sourceFiles, publicPrefix);
-    const enginePrivate = [
+    const publicFiles = stripTaskDirectory(sourceFiles, publicPrefix);
+    const privateFiles = [
         ...stripTaskDirectory(sourceFiles, testsPrefix),
         ...stripTaskDirectory(sourceFiles, solutionPrefix),
     ].sort((left, right) => left.path.localeCompare(right.path));
@@ -473,8 +488,8 @@ async function readWorkbenchEngineCase(args) {
                 : {}),
         },
         files: {
-            subjectVisible,
-            enginePrivate,
+            public: publicFiles,
+            private: privateFiles,
             source: sourceFiles,
         },
     };
@@ -543,11 +558,11 @@ async function fileExists(filePath) {
     return fs.stat(filePath).then((stat) => stat.isFile(), () => false);
 }
 async function readTestsResult(args) {
-    const rewardJson = await readOptionalJson(path.join(args.logsRoot, "verifier", "reward.json"));
+    const rewardJson = await readOptionalJson(path.join(args.verifierRoot, "reward.json"));
     if (rewardJson) {
         return normalizeTestsResult(rewardJson, args.caseId);
     }
-    const rewardText = await fs.readFile(path.join(args.logsRoot, "verifier", "reward.txt"), "utf8").catch((error) => {
+    const rewardText = await fs.readFile(path.join(args.verifierRoot, "reward.txt"), "utf8").catch((error) => {
         if (error.code === "ENOENT") {
             return null;
         }
@@ -560,7 +575,10 @@ async function readTestsResult(args) {
         }
         return normalizeTestsResult({ reward: score }, args.caseId);
     }
-    throw new Error("Tests engine did not find reward.json or reward.txt under the request logs verifier directory.");
+    throw new Error("Tests engine did not find reward.json or reward.txt under its verifier output directory.");
+}
+function testsVerifierOutputDir(outputRoot) {
+    return path.join(outputRoot, ".workbench", "internal", "verifier");
 }
 async function readOptionalJson(filePath) {
     const source = await fs.readFile(filePath, "utf8").catch((error) => {
@@ -640,7 +658,7 @@ function workloadFromAdapterOperationRequest(request) {
     };
 }
 function isBuiltInAgentAdapterId(value) {
-    return value === "codex" || value === "claude" || value === "pi";
+    return value === "codex" || value === "claude";
 }
 function builtInAgentSpecFromRequest(request) {
     const config = adapterCommandConfigRecord(request);
@@ -720,7 +738,7 @@ async function writeAgentSubjectOutput(request, workload, subject, options = {})
         adapterAuthRequest: options.adapterAuthRequest,
         adapterAuthEnv: options.adapterAuthEnv,
         workspaceRoot: request.paths.workspace,
-        cwd: request.paths.cwd ?? request.paths.workspace,
+        cwd: request.paths.workspace,
         prompt: buildAgentSubjectPrompt(workload, subject),
         traceRoot,
         jobId: workload.job.id,
@@ -763,8 +781,10 @@ function buildAgentSubjectPrompt(workload, subject) {
     return [
         ...(subject.instructions ? ["Instructions:", subject.instructions, ""] : []),
         "Context:",
-        "- Subject files are mounted at /workspace/input/subject.",
-        "- Subject files are also present in the task working directory.",
+        "- Subject source files are mounted at /workspace/input/subject.",
+        "- Follow any subject guidance, skill files, scripts, or configuration under /workspace/input/subject.",
+        "- The mutable working directory is /workspace.",
+        "- If the subject declares prepare.command, it has already run and may have copied files into /workspace.",
         ...(workload.case?.prompt ? ["Case:", workload.case.prompt, ""] : []),
         "- Public case files are mounted at /workspace/input/case.",
         "- Verifier tests are not present while you run.",
@@ -784,14 +804,14 @@ async function writeAgentSubjectRevisionOutput(request, workload, optimizer, opt
         adapterAuthRequest: options.adapterAuthRequest,
         adapterAuthEnv: options.adapterAuthEnv,
         workspaceRoot: request.paths.workspace,
-        cwd: request.paths.cwd ?? request.paths.workspace,
+        cwd: request.paths.workspace,
         prompt: buildAgentOptimizerPrompt(workload),
         traceRoot,
         jobId: workload.job.id,
     });
     const subjectPatch = await createSubjectPatchFromWorkspace({
         beforeRoot: requiredRequestPath(request.paths.subject, "paths.subject"),
-        afterRoot: request.paths.cwd ?? request.paths.workspace,
+        afterRoot: request.paths.workspace,
         edits: workload.optimizer.edits,
     });
     const changedSubjectPaths = subjectPatch.fileChanges.filter((filePath) => isSubjectEditPath(filePath, workload.optimizer.edits));
@@ -839,8 +859,10 @@ function buildAgentOptimizerPrompt(workload) {
         workload.benchmark.description || workload.benchmark.name,
         "",
         "Context:",
-        "- Subject files are mounted at /workspace/input/subject.",
-        "- Subject files are also present in the current working directory.",
+        "- Subject source files are mounted at /workspace/input/subject.",
+        "- Follow any subject guidance, skill files, scripts, or configuration under /workspace/input/subject.",
+        "- The mutable working directory is /workspace.",
+        "- If the subject declares prepare.command, it has already run and may have copied files into /workspace.",
         "- Prior run traces are mounted at /workspace/input/traces.",
         "- Use /workspace/input/traces as the source of truth for what happened in prior attempts.",
         "- Do not mutate /workspace/input.",
@@ -849,7 +871,7 @@ function buildAgentOptimizerPrompt(workload) {
         workload.optimizer.edits.map((entry) => `- ${entry}`).join("\n"),
         "",
         "Output:",
-        "- Mutate the editable subject files directly in the current working directory.",
+        "- Create or mutate editable subject files directly in the current working directory.",
         "- Include at least one changed subject file covered by the optimizer edits list.",
     ].join("\n");
 }
@@ -873,6 +895,14 @@ async function writeRubricJudgeResult(request, workload, engine, options = {}) {
         engine,
         criterionRuns,
     });
+    await writeRubricEvidenceFiles({
+        request,
+        workload,
+        engine,
+        result,
+        criterionRuns,
+        usage,
+    });
     await writeWorkbenchAdapterOperationResult(request.paths.output, {
         protocol: "workbench.adapter-result.v1",
         operation: "engine.run",
@@ -886,7 +916,7 @@ async function writeRubricJudgeResult(request, workload, engine, options = {}) {
             aggregation: "weighted_mean",
             criteria: criterionRuns.map((run) => ({
                 id: run.result.criterion_id,
-                traceRoot: run.traceRoot,
+                traceFiles: run.traceFiles.map((file) => file.path),
                 metadata: run.metadata,
                 ...(run.repair ? { repair: run.repair } : {}),
             })),
@@ -894,8 +924,76 @@ async function writeRubricJudgeResult(request, workload, engine, options = {}) {
         ...(usage ? { usage } : {}),
     });
 }
+async function writeRubricEvidenceFiles(args) {
+    const root = `.workbench/traces/${args.workload.job.id}/engine/rubric`;
+    const scorecard = {
+        schema: "workbench.engine.rubric.evidence.v1",
+        safeForOptimizer: true,
+        jobId: args.workload.job.id,
+        subjectId: args.workload.subjectId,
+        attemptIndex: args.workload.attemptIndex,
+        sampleIndex: args.workload.sampleIndex,
+        caseId: args.workload.caseId,
+        judge: args.engine.judge.use,
+        parallelism: args.engine.parallelism,
+        aggregation: "weighted_mean",
+        score: args.result.score,
+        metrics: args.result.metrics ?? {},
+        summary: args.result.summary ?? null,
+        criteria: args.criterionRuns.map((run) => ({
+            id: run.result.criterion_id,
+            label: run.result.label,
+            score: run.result.score,
+            pass: run.result.pass,
+            rationale: run.result.rationale ?? null,
+            errors: run.result.errors ?? [],
+            summary: run.summary ?? null,
+            metadata: safeRubricEvidenceMetadata(run.metadata),
+            repair: run.repair ?? null,
+        })),
+        ...(args.usage ? { usage: args.usage } : {}),
+    };
+    await writeSurfaceFiles(args.request.paths.output, [
+        jsonSurfaceFile(`${root}/scorecard.json`, scorecard),
+        ...args.criterionRuns.map((run) => jsonSurfaceFile(`${root}/criteria/${safeInternalPathSegment(run.result.criterion_id)}/result.json`, {
+            schema: "workbench.engine.rubric.criterion-evidence.v1",
+            safeForOptimizer: true,
+            criterion: args.engine.criteria.find((criterion) => criterion.id === run.result.criterion_id) ?? {
+                id: run.result.criterion_id,
+            },
+            result: run.result,
+            summary: run.summary ?? null,
+            metadata: safeRubricEvidenceMetadata(run.metadata),
+            repair: run.repair ?? null,
+        })),
+        ...args.criterionRuns.flatMap((run) => run.traceFiles),
+    ]);
+}
+function safeRubricEvidenceMetadata(metadata) {
+    const record = metadata && typeof metadata === "object" && !Array.isArray(metadata)
+        ? metadata
+        : {};
+    const safe = {};
+    for (const key of ["providerId", "sessionId", "eventCount", "model"]) {
+        const value = record[key];
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+            safe[key] = value;
+        }
+    }
+    return Object.keys(safe).length > 0 ? safe : null;
+}
+function jsonSurfaceFile(pathname, value) {
+    return {
+        path: pathname,
+        kind: "text",
+        encoding: "utf8",
+        executable: false,
+        content: `${JSON.stringify(value, null, 2)}\n`,
+    };
+}
 async function runRubricCriterionJudge(args) {
     const traceRoot = path.join(args.request.paths.output, ".workbench", "internal", "rubric", safeInternalPathSegment(args.criterion.id));
+    const tracePath = rubricCriterionTracePath(args.workload.job.id, args.criterion.id, "judge");
     const agentResult = await executeBuiltInAgentTurn(args.agentExecutor, {
         role: "engine",
         provider: args.engine.judge,
@@ -903,9 +1001,10 @@ async function runRubricCriterionJudge(args) {
         adapterAuthRequest: args.adapterAuthRequest,
         adapterAuthEnv: args.adapterAuthEnv,
         workspaceRoot: args.request.paths.workspace,
-        cwd: args.request.paths.cwd ?? args.request.paths.workspace,
+        cwd: args.request.paths.workspace,
         prompt: buildRubricCriterionJudgePrompt(args.workload, args.engine, args.criterion),
         traceRoot: path.join(traceRoot, "judge"),
+        tracePath,
         jobId: args.workload.job.id,
     });
     let usage = args.runtime.assignUsageRole("engine", agentResult.usage);
@@ -913,12 +1012,13 @@ async function runRubricCriterionJudge(args) {
         return {
             ...normalizeRubricCriterionJudgeResult(agentResult.output, args.criterion),
             metadata: agentResult.metadata,
-            traceRoot,
+            traceFiles: publicRubricAgentTraceFiles(agentResult.traceFiles),
             ...(usage ? { usage } : {}),
         };
     }
     catch (error) {
         const repairError = error instanceof Error ? error.message : String(error);
+        const repairTracePath = rubricCriterionTracePath(args.workload.job.id, args.criterion.id, "repair");
         const repairResult = await executeBuiltInAgentTurn(args.agentExecutor, {
             role: "engine",
             provider: args.engine.judge,
@@ -926,13 +1026,14 @@ async function runRubricCriterionJudge(args) {
             adapterAuthRequest: args.adapterAuthRequest,
             adapterAuthEnv: args.adapterAuthEnv,
             workspaceRoot: args.request.paths.workspace,
-            cwd: args.request.paths.cwd ?? args.request.paths.workspace,
+            cwd: args.request.paths.workspace,
             prompt: buildRubricCriterionRepairPrompt({
                 output: agentResult.output,
                 error: repairError,
                 criterion: args.criterion,
             }),
             traceRoot: path.join(traceRoot, "repair"),
+            tracePath: repairTracePath,
             jobId: args.workload.job.id,
         });
         usage = args.runtime.mergeUsageSummaries([
@@ -949,7 +1050,10 @@ async function runRubricCriterionJudge(args) {
                     originalMetadata: agentResult.metadata,
                 },
             },
-            traceRoot,
+            traceFiles: publicRubricAgentTraceFiles([
+                ...agentResult.traceFiles,
+                ...repairResult.traceFiles,
+            ]),
             repair: {
                 attempted: true,
                 originalError: repairError,
@@ -958,6 +1062,14 @@ async function runRubricCriterionJudge(args) {
         };
     }
 }
+function publicRubricAgentTraceFiles(files) {
+    return files
+        .filter((file) => file.encoding === "utf8" && file.path.endsWith("/trace.json"))
+        .map((file) => ({ ...file }));
+}
+function rubricCriterionTracePath(jobId, criterionId, turn) {
+    return `.workbench/traces/${jobId}/engine/rubric/criteria/${safeInternalPathSegment(criterionId)}/${turn}`;
+}
 function buildRubricCriterionJudgePrompt(workload, engine, criterion) {
     requireWorkloadTask(workload, "Rubric judge");
     return [
@@ -981,7 +1093,7 @@ function buildRubricCriterionJudgePrompt(workload, engine, criterion) {
             score: 0.0,
             pass: false,
             rationale: "why this criterion received this score",
-            summary: "short grading summary",
+            summary: "short scoring summary",
             feedback: {},
         }, null, 2),
         `The only allowed criterion_id is ${criterion.id}.`,
@@ -1009,7 +1121,7 @@ function buildRubricCriterionRepairPrompt(input) {
             score: 0.0,
             pass: false,
             rationale: "why this criterion received this score",
-            summary: "short grading summary",
+            summary: "short scoring summary",
             feedback: {},
         }, null, 2),
         "",
@@ -1026,9 +1138,6 @@ function rubricJudgeResultFromCriteria(args) {
         throw new Error("Rubric criterion scores must aggregate to a score in the 0..1 range.");
     }
     const metrics = { score };
-    for (const criterion of criteria) {
-        metrics[`criterion__${criterion.criterion_id}`] = criterion.score;
-    }
     const caseResult = rubricJudgeCaseResult({
         workload: args.workload,
         score,
@@ -1196,8 +1305,6 @@ function isRuntimeWorkspacePath(filePath) {
         normalized.startsWith("input/") ||
         normalized === "output" ||
         normalized.startsWith("output/") ||
-        normalized === "logs" ||
-        normalized.startsWith("logs/") ||
         normalized === "private" ||
         normalized.startsWith("private/");
 }

package/dist/local-traces.d.ts

@@ -0,0 +1,5 @@
+import { sortLocalTraceRefs, type AgentReadableTraceDigest, type LocalTraceAdapter, type LocalTraceRef } from "@workbench-ai/agent-driver";
+export declare function builtinLocalTraceAdapters(): LocalTraceAdapter[];
+export declare function builtinLocalTraceAdapter(id: string): LocalTraceAdapter | null;
+export { sortLocalTraceRefs, type AgentReadableTraceDigest, type LocalTraceAdapter, type LocalTraceRef, };
+//# sourceMappingURL=local-traces.d.ts.map

package/dist/local-traces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-traces.d.ts","sourceRoot":"","sources":["../src/local-traces.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,aAAa,EACnB,MAAM,4BAA4B,CAAC;AASpC,wBAAgB,yBAAyB,IAAI,iBAAiB,EAAE,CAE/D;AAED,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAE7E;AAED,OAAO,EACL,kBAAkB,EAClB,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,aAAa,GACnB,CAAC"}

package/dist/local-traces.js

@@ -0,0 +1,14 @@
+import { sortLocalTraceRefs, } from "@workbench-ai/agent-driver";
+import { claudeLocalTraceAdapter } from "@workbench-ai/agent-driver-anthropic-claude-code";
+import { codexLocalTraceAdapter } from "@workbench-ai/agent-driver-openai-codex";
+const BUILT_IN_LOCAL_TRACE_ADAPTERS = [
+    codexLocalTraceAdapter,
+    claudeLocalTraceAdapter,
+];
+export function builtinLocalTraceAdapters() {
+    return [...BUILT_IN_LOCAL_TRACE_ADAPTERS];
+}
+export function builtinLocalTraceAdapter(id) {
+    return BUILT_IN_LOCAL_TRACE_ADAPTERS.find((adapter) => adapter.id === id) ?? null;
+}
+export { sortLocalTraceRefs, };

package/dist/manifests.d.ts

@@ -1,5 +1,5 @@
 import type { WorkbenchAdapterManifest } from "@workbench-ai/workbench-protocol";
-export type WorkbenchPublicBuiltInAdapterId = "workbench" | "codex" | "claude" | "pi" | "command";
+export type WorkbenchPublicBuiltInAdapterId = "workbench" | "codex" | "claude" | "command";
 export type WorkbenchEngineHelperAdapterId = "rubric" | "tests";
 export type WorkbenchBuiltInAdapterId = WorkbenchPublicBuiltInAdapterId | WorkbenchEngineHelperAdapterId;
 export declare function builtinWorkbenchAdapterManifest(id: string): WorkbenchAdapterManifest | null;

package/dist/manifests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifests.d.ts","sourceRoot":"","sources":["../src/manifests.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACzB,MAAM,kCAAkC,CAAC;AAW1C,MAAM,MAAM,+BAA+B,GACvC,WAAW,GACX,OAAO,GACP,QAAQ,GACR,IAAI,GACJ,SAAS,CAAC;AAEd,MAAM,MAAM,8BAA8B,GACtC,QAAQ,GACR,OAAO,CAAC;AAEZ,MAAM,MAAM,yBAAyB,GACjC,+BAA+B,GAC/B,8BAA8B,CAAC;AAuFnC,wBAAgB,+BAA+B,CAAC,EAAE,EAAE,MAAM,GAAG,wBAAwB,GAAG,IAAI,CAI3F;AAED,wBAAgB,gCAAgC,IAAI,wBAAwB,EAAE,CAI7E;AAED,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,MAAM,GAAG,EAAE,IAAI,yBAAyB,CAEvF;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D"}
+{"version":3,"file":"manifests.d.ts","sourceRoot":"","sources":["../src/manifests.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACzB,MAAM,kCAAkC,CAAC;AAW1C,MAAM,MAAM,+BAA+B,GACvC,WAAW,GACX,OAAO,GACP,QAAQ,GACR,SAAS,CAAC;AAEd,MAAM,MAAM,8BAA8B,GACtC,QAAQ,GACR,OAAO,CAAC;AAEZ,MAAM,MAAM,yBAAyB,GACjC,+BAA+B,GAC/B,8BAA8B,CAAC;AA+EnC,wBAAgB,+BAA+B,CAAC,EAAE,EAAE,MAAM,GAAG,wBAAwB,GAAG,IAAI,CAI3F;AAED,wBAAgB,gCAAgC,IAAI,wBAAwB,EAAE,CAI7E;AAED,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,MAAM,GAAG,EAAE,IAAI,yBAAyB,CAEvF;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D"}

package/dist/manifests.js

@@ -3,7 +3,7 @@ const BUILT_IN_ADAPTER_MANIFESTS = Object.fromEntries(Object.entries({
     workbench: defineAdapter({
         id: "workbench",
         engineResolve: defineEngineResolver(),
-        engineRun: defineEngineRunner(),
+        engineRun: defineEngineRunner({ executor: "host" }),
         slots: {
             score: adapterSlot("/score", "engine.run"),
         },
@@ -55,14 +55,6 @@ const BUILT_IN_ADAPTER_MANIFESTS = Object.fromEntries(Object.entries({
             },
         },
     }),
-    pi: defineAdapter({
-        id: "pi",
-        subject: defineSubject(),
-        improve: defineOptimizer(),
-        setup: [
-            "npm install --global @mariozechner/pi-coding-agent@0.70.2",
-        ],
-    }),
     command: defineAdapter({
         id: "command",
         subject: defineSubject(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workbench-ai/workbench-built-in-adapters",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "type": "module",
   "repository": {
     "type": "git",
@@ -13,6 +13,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./local-traces": {
+      "types": "./dist/local-traces.d.ts",
+      "default": "./dist/local-traces.js"
     }
   },
   "bin": {
@@ -21,21 +25,19 @@
     "workbench-adapter-tests": "dist/bin/tests.js",
     "workbench-adapter-rubric": "dist/bin/rubric.js",
     "workbench-adapter-codex": "dist/bin/codex.js",
-    "workbench-adapter-claude": "dist/bin/claude.js",
-    "workbench-adapter-pi": "dist/bin/pi.js"
+    "workbench-adapter-claude": "dist/bin/claude.js"
   },
   "files": [
     "dist"
   ],
   "dependencies": {
     "yaml": "^2.8.2",
-    "@workbench-ai/agent-driver-anthropic-claude-code": "0.0.44",
-    "@workbench-ai/agent-driver-badlogic-pi-coding-agent": "0.0.44",
-    "@workbench-ai/agent-driver-openai-codex": "0.0.44",
-    "@workbench-ai/workbench-contract": "0.0.46",
-    "@workbench-ai/agent-driver": "0.0.44",
-    "@workbench-ai/workbench-protocol": "0.0.46",
-    "@workbench-ai/workbench-core": "0.0.46"
+    "@workbench-ai/agent-driver-anthropic-claude-code": "0.0.45",
+    "@workbench-ai/agent-driver-openai-codex": "0.0.45",
+    "@workbench-ai/agent-driver": "0.0.45",
+    "@workbench-ai/workbench-contract": "0.0.48",
+    "@workbench-ai/workbench-core": "0.0.48",
+    "@workbench-ai/workbench-protocol": "0.0.48"
   },
   "devDependencies": {
     "@types/node": "^24.3.1",

package/dist/bin/pi.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=pi.d.ts.map

package/dist/bin/pi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pi.d.ts","sourceRoot":"","sources":["../../src/bin/pi.ts"],"names":[],"mappings":""}

package/dist/bin/pi.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import { executeWorkbenchBuiltInAdapterCommand } from "../execute.js";
-await executeWorkbenchBuiltInAdapterCommand({ adapterId: "pi" });