@workbench-ai/workbench-built-in-adapters 0.0.67 → 0.0.69

package/dist/agent-turn.js

@@ -244,9 +244,9 @@ function defaultWorkbenchAgentConfig(provider, providerName) {
     };
 }
 async function resolveAgentAuth(provider, providerSpec, workspaceRoot, agentHome, adapterAuth) {
-    const candidate = adapterAuthProviderCandidate(adapterAuth.request, providerSpec.use) ??
+    const authConfig = adapterAuthProviderOption(adapterAuth.request, providerSpec.use) ??
         (provider.manifest.defaults.auth ?? {});
-    const parsed = provider.schemas.auth.safeParse(candidate);
+    const parsed = provider.schemas.auth.safeParse(authConfig);
     if (!parsed.success) {
         throw new Error(`Agent provider "${provider.manifest.id}" auth is invalid: ${formatValidationIssues(parsed.error.issues)}`);
     }
@@ -254,7 +254,7 @@ async function resolveAgentAuth(provider, providerSpec, workspaceRoot, agentHome
     void agentHome;
     return { ...parsed.data };
 }
-function adapterAuthProviderCandidate(auth, providerName) {
+function adapterAuthProviderOption(auth, providerName) {
     const record = jsonRecord(auth);
     const self = jsonRecord(record?.self);
     const adapters = jsonRecord(record?.adapters);

package/dist/execute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../src/execute.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,IAAI,EAKL,MAAM,kCAAkC,CAAC;AAoB1C,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;AAwDD,wBAAsB,qCAAqC,CACzD,IAAI,GAAE,4CAAiD,GACtD,OAAO,CAAC,IAAI,CAAC,CAiDf"}
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../src/execute.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,IAAI,EAKL,MAAM,kCAAkC,CAAC;AAqB1C,OAAO,KAAK,EAEV,0BAA0B,EAG3B,MAAM,iBAAiB,CAAC;AAOzB,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;AA2DD,wBAAsB,qCAAqC,CACzD,IAAI,GAAE,4CAAiD,GACtD,OAAO,CAAC,IAAI,CAAC,CAyDf"}

package/dist/execute.js

@@ -2,17 +2,18 @@ import { spawn } from "node:child_process";
 import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { jsonRecord, normalizeRelativePath, readSurfaceFiles, writeSurfaceFiles, } from "@workbench-ai/workbench-core";
-import { ensureWorkbenchAdapterOutputDir, readWorkbenchAdapterOperationResult, readWorkbenchAdapterOperationRequest, runWorkbenchRuntimeOperationSequence, writeWorkbenchAdapterOperationResult, workbenchAdapterOperationResultPath, } from "@workbench-ai/workbench-protocol";
+import { createWorkbenchExecutionEventPublisher, jsonRecord, normalizeRelativePath, publishCommandStepEvent, readSurfaceFiles, writeSurfaceFiles, } from "@workbench-ai/workbench-core";
+import { ensureWorkbenchAdapterOutputDir, readWorkbenchAdapterOperationResult, readWorkbenchAdapterOperationRequest, writeWorkbenchAdapterOperationResult, workbenchAdapterOperationResultPath, } from "@workbench-ai/workbench-protocol";
 import YAML from "yaml";
-import { isWorkbenchBuiltInAdapterId, adapterCommandName, } from "./manifests.js";
+import { isWorkbenchBuiltInAdapterId, } from "./manifests.js";
 import { importWorkbenchRuntime } from "./runtime.js";
 const DIRECT_ADAPTER_HANDLERS = {
     command: executeCommandAdapterRequest,
     tests: executeTestsEngineRequest,
     workbench: executeWorkbenchEngineRequest,
 };
-const TASK_CONTROL_FILE = "task.yaml";
+const CASE_CONTROL_FILE = "case.yaml";
+const COMMAND_SKILL_PATCH_FILE = "skill-patch.json";
 const DEFAULT_RUBRIC_PARALLELISM = 4;
 export async function executeWorkbenchBuiltInAdapterCommand(args = {}) {
     const request = await readWorkbenchAdapterOperationRequest(args.requestPath);
@@ -32,10 +33,19 @@ export async function executeWorkbenchBuiltInAdapterCommand(args = {}) {
         adapterAuthRoot: args.adapterAuthRoot,
         adapterAuthRequest: args.adapterAuthRequest ?? request.auth,
         adapterAuthEnv: args.adapterAuthEnv,
+        eventPublisher: eventPublisherForAdapterRequest(request),
     };
     const directHandler = DIRECT_ADAPTER_HANDLERS[adapterId];
     if (directHandler) {
-        await directHandler(request);
+        await publishDirectAdapterStep(agentOptions.eventPublisher, adapterId, request, "started");
+        try {
+            await directHandler(request);
+            await publishDirectAdapterStep(agentOptions.eventPublisher, adapterId, request, "succeeded");
+        }
+        catch (error) {
+            await publishDirectAdapterStep(agentOptions.eventPublisher, adapterId, request, "failed", error);
+            throw error;
+        }
         return;
     }
     if (adapterId === "rubric") {
@@ -48,17 +58,34 @@ export async function executeWorkbenchBuiltInAdapterCommand(args = {}) {
     if (isBuiltInAgentAdapterId(adapterId)) {
         const workload = workloadFromAdapterOperationRequest(request);
         const agent = builtInAgentSpecFromRequest(request);
-        if (request.operation === "candidate.improve") {
-            await writeAgentCandidateRevisionOutput(request, workload, agent, agentOptions);
+        if (request.operation === "skill.improve") {
+            await writeAgentSkillRevisionOutput(request, workload, agent, agentOptions);
             return;
         }
-        if (request.operation === "candidate.run") {
-            await writeAgentCandidateOutput(request, workload, agent, agentOptions);
+        if (request.operation === "skill.run") {
+            await writeAgentSkillOutput(request, workload, agent, agentOptions);
             return;
         }
         throw new Error(`Agent adapter ${adapterId} cannot handle ${request.operation}.`);
     }
 }
+async function publishDirectAdapterStep(publisher, adapterId, request, status, error) {
+    await publishCommandStepEvent(publisher, {
+        step: `${adapterId}.${request.operation}`,
+        status,
+        role: directAdapterProgressRole(request.operation),
+        ...(error ? { error: error instanceof Error ? error.message : String(error) } : {}),
+    });
+}
+function directAdapterProgressRole(operation) {
+    if (operation === "skill.run") {
+        return "runner";
+    }
+    if (operation === "skill.improve") {
+        return "improver";
+    }
+    return "engine";
+}
 async function executeWorkbenchEngineRequest(request) {
     if (request.operation === "engine.resolve") {
         await executeWorkbenchEngineResolveRequest(request);
@@ -71,13 +98,13 @@ async function executeWorkbenchEngineRequest(request) {
     throw new Error(`Workbench engine adapter cannot handle ${request.operation}.`);
 }
 async function executeWorkbenchEngineResolveRequest(request) {
-    const configuredPath = workbenchEngineTasksPath(request);
+    const configuredPath = workbenchEngineCasesPath(request);
     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}`);
+        throw new Error(`Workbench engine cases path is not a directory: ${sourcePath}`);
     }
-    const cases = await readEngineCasesFromWorkbenchTaskRoot(sourcePath);
+    const cases = await readEngineCasesFromWorkbenchCaseRoot(sourcePath);
     await writeWorkbenchAdapterOperationResult(request.paths.output, {
         protocol: "workbench.adapter-result.v1",
         operation: "engine.resolve",
@@ -91,187 +118,20 @@ async function executeWorkbenchEngineResolveRequest(request) {
     });
 }
 async function executeWorkbenchEngineRunRequest(request) {
-    const outcome = await 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",
-        ok: true,
-        value: outcome.result,
-        ...(usage ? { usage } : {}),
-        ...(outcome.summary !== undefined ? { summary: outcome.summary } : {}),
-        ...(outcome.feedback !== undefined ? { feedback: outcome.feedback } : {}),
-    });
+    void request;
+    throw new Error("Workbench engine.run is no longer an orchestration adapter. Run the selected skill in core and invoke the score adapter directly.");
 }
-async function workbenchEngineOutcomeUsage(outcome) {
-    const runtime = await importWorkbenchRuntime();
-    const operationUsage = outcome.usage
-        ? undefined
-        : runtime.mergeUsageSummaries(outcome.operationResults.map((result) => {
-            if (result.operation === "candidate.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) {
+function workbenchEngineCasesPath(request) {
     const config = adapterCommandConfigRecord(request);
-    const tasks = config.tasks;
-    if (tasks === undefined) {
-        return "tasks";
-    }
-    const taskConfig = jsonRecord(tasks);
-    if (typeof taskConfig.path === "string" && taskConfig.path.trim().length > 0) {
-        return taskConfig.path;
-    }
-    throw new Error("Workbench engine tasks must be an object with path.");
-}
-function workbenchEngineScoreInvocation(request) {
-    const score = jsonRecord(adapterCommandConfigRecord(request).score);
-    if (!score || typeof score.use !== "string" || score.use.length === 0) {
-        throw new Error("Workbench engine requires invocation.with.score.use.");
-    }
-    return {
-        use: score.use,
-        with: (score.with ?? {}),
-        ...(score.auth !== undefined ? { auth: score.auth } : {}),
-        command: typeof score.command === "string" && score.command.length > 0
-            ? score.command
-            : adapterCommandName(score.use),
-    };
-}
-function workbenchEngineCandidateInvocation(request) {
-    const candidate = request.context?.candidate?.run;
-    if (!candidate?.use || !candidate.command) {
-        throw new Error("Workbench engine requires context.candidate.run.use and context.candidate.run.command.");
-    }
-    return {
-        use: candidate.use,
-        with: (candidate.with ?? {}),
-        ...(candidate.auth !== undefined ? { auth: candidate.auth } : {}),
-        command: candidate.command,
-    };
-}
-async function workbenchEngineGradingIsolation(request) {
-    const grading = jsonRecord(adapterCommandConfigRecord(request).grading);
-    const isolation = grading?.isolation;
-    if (isolation !== undefined &&
-        isolation !== "shared" &&
-        isolation !== "separate") {
-        throw new Error("Workbench engine grading.isolation must be shared or separate.");
-    }
-    if (await workbenchEnginePrivateFilesPresent(request)) {
-        return "separate";
-    }
-    return isolation ?? "shared";
-}
-async function workbenchEnginePrivateFilesPresent(request) {
-    if (!request.paths.enginePrivate) {
-        return false;
-    }
-    const files = await readOptionalSurfaceFiles(request.paths.enginePrivate);
-    return files.length > 0;
-}
-async function runWorkbenchEngineSharedGrading(request) {
-    const inputs = await workbenchEngineRuntimeInputs(request);
-    const candidate = workbenchEngineCandidateInvocation(request);
-    const score = workbenchEngineScoreInvocation(request);
-    const result = await runWorkbenchRuntimeOperationSequence({
-        inputs,
-        prepare: true,
-        operations: [
-            { label: "candidate", operation: "candidate.run", invocation: candidate },
-            { label: "score", operation: "engine.run", invocation: score },
-        ],
-    });
-    assertRuntimeControlResultOk(result, "Workbench shared grading");
-    return result;
-}
-async function runWorkbenchEngineSeparateGrading(request) {
-    const inputs = await workbenchEngineRuntimeInputs(request);
-    const candidate = workbenchEngineCandidateInvocation(request);
-    const score = workbenchEngineScoreInvocation(request);
-    const runtime = await importWorkbenchRuntime();
-    const runner = await runWorkbenchRuntimeOperationSequence({
-        inputs: {
-            candidate: inputs.candidate,
-            case: inputs.case,
-            traces: inputs.traces,
-        },
-        prepare: true,
-        collectWorkspace: true,
-        operations: [
-            { label: "candidate", operation: "candidate.run", invocation: candidate },
-        ],
-    });
-    assertRuntimeControlResultOk(runner, "Workbench separate runner");
-    const grader = await runWorkbenchRuntimeOperationSequence({
-        inputs: {
-            candidate: inputs.candidate,
-            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 workbenchEngineRuntimeInputs(request) {
-    const [candidate, caseFiles, enginePrivate, traces] = await Promise.all([
-        readOptionalSurfaceFiles(request.paths.candidate),
-        readOptionalSurfaceFiles(request.paths.case),
-        readOptionalSurfaceFiles(request.paths.enginePrivate),
-        readOptionalSurfaceFiles(request.paths.traces),
-    ]);
-    return {
-        candidate,
-        case: caseFiles,
-        enginePrivate,
-        traces,
-    };
-}
-async function readOptionalSurfaceFiles(root) {
-    if (!root) {
-        return [];
+    const cases = config.cases;
+    if (cases === undefined) {
+        return "cases";
     }
-    return await readSurfaceFiles(root).catch((error) => {
-        if (error.code === "ENOENT") {
-            return [];
-        }
-        throw error;
-    });
-}
-function assertRuntimeControlResultOk(result, label) {
-    if (result.ok) {
-        return;
+    const caseConfig = jsonRecord(cases);
+    if (typeof caseConfig.path === "string" && caseConfig.path.trim().length > 0) {
+        return caseConfig.path;
     }
-    throw new Error(`${label} failed${result.error ? `: ${result.error}` : "."}`);
+    throw new Error("Workbench engine cases must be an object with path.");
 }
 function dedupeSurfaceFiles(files) {
     const byPath = new Map();
@@ -284,36 +144,18 @@ function dedupeSurfaceFiles(files) {
     }
     return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
-function remapRuntimeControlTraceFile(request, file) {
-    const normalized = normalizeRelativePath(file.path);
-    if (!normalized.startsWith(".workbench/traces/")) {
-        return { ...file, path: normalized };
-    }
-    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 {
-        ...file,
-        path: `.workbench/traces/${request.jobId ?? request.id}/${rest.join("/")}`,
-    };
-}
 function safeInternalPathSegment(value) {
     const safe = value.replace(/[^a-z0-9._-]+/giu, "_").replace(/^_+|_+$/gu, "");
     return safe || "nested";
 }
 async function executeCommandAdapterRequest(request) {
     const command = requiredAdapterCommandString(request, "command");
-    const before = request.operation === "candidate.improve"
-        ? await snapshotEditableCandidateWorkspace(request)
+    await ensureRunSkillDirectories(request);
+    const before = request.operation === "skill.improve"
+        ? await snapshotEditableSkillWorkspace(request)
         : null;
     try {
-        await runAdapterShellCommand(command, request.paths.workspace);
+        await runAdapterShellCommand(command, commandAdapterWorkingDirectory(request), commandAdapterEnvironment(request));
         if (request.operation === "engine.run") {
             await requireCommandScoreResult(request);
             return;
@@ -336,6 +178,7 @@ async function executeTestsEngineRequest(request) {
     if (request.operation !== "engine.run") {
         throw new Error(`Tests adapter cannot handle ${request.operation}.`);
     }
+    await ensureRunSkillDirectories(request);
     const testsRoot = requiredRequestPath(request.paths.enginePrivate, "paths.enginePrivate");
     const verifierRoot = testsVerifierOutputDir(request.paths.output);
     await fs.rm(verifierRoot, { recursive: true, force: true }).catch(() => undefined);
@@ -348,7 +191,12 @@ async function executeTestsEngineRequest(request) {
         throw new Error(`Tests engine requires ${path.join(testsRoot, "test.sh")}.`);
     }
     await runAdapterShellCommand(`sh ${shellQuote(script)}`, request.paths.workspace, {
+        SKILL_DIR: request.paths.skill ?? path.join(request.paths.workspace, "input", "skills", "primary"),
+        SKILLS_DIR: request.paths.skills ?? path.join(request.paths.workspace, "input", "skills"),
+        CASE_DIR: request.paths.case ?? path.join(request.paths.workspace, "input", "case"),
+        OUTPUT_DIR: request.paths.output,
         WORKBENCH_TESTS_VERIFIER_DIR: verifierRoot,
+        WORKBENCH_CASE_ID: request.context?.attempt?.caseId ?? "current",
     });
     const result = await readTestsResult({
         verifierRoot,
@@ -387,16 +235,100 @@ async function runAdapterShellCommand(command, cwd, env = {}) {
         });
     });
 }
+function commandAdapterWorkingDirectory(request) {
+    return request.operation === "skill.improve"
+        ? requiredRequestPath(request.paths.skill, "paths.skill")
+        : request.paths.workspace;
+}
+function commandAdapterEnvironment(request) {
+    return {
+        SKILL_DIR: request.paths.skill ?? path.join(request.paths.workspace, "input", "skills", "primary"),
+        SKILLS_DIR: request.paths.skills ?? path.join(request.paths.workspace, "input", "skills"),
+        CASE_DIR: request.paths.case ?? path.join(request.paths.workspace, "input", "case"),
+        TRACE_DIR: request.paths.traces ?? path.join(request.paths.workspace, "input", "traces"),
+        OUTPUT_DIR: request.paths.output,
+        WORKBENCH_SKILL_PATCH: commandSkillPatchPath(request),
+        WORKBENCH_CASE_ID: request.context?.attempt?.caseId ?? "current",
+    };
+}
+async function ensureRunSkillDirectories(request) {
+    if (request.operation === "skill.improve") {
+        return;
+    }
+    await Promise.all([
+        request.paths.skills ? fs.mkdir(request.paths.skills, { recursive: true }) : Promise.resolve(),
+        request.paths.skill ? fs.mkdir(request.paths.skill, { recursive: true }) : Promise.resolve(),
+    ]);
+}
+function commandSkillPatchPath(request) {
+    return path.join(request.paths.output, COMMAND_SKILL_PATCH_FILE);
+}
+async function readSkillPatchFile(filePath) {
+    if (!await fileExists(filePath)) {
+        return null;
+    }
+    const record = jsonRecord(JSON.parse(await fs.readFile(filePath, "utf8")));
+    const rawFiles = Array.isArray(record.files) ? record.files : [];
+    const files = rawFiles.map((entry, index) => {
+        if (!isPatchSurfaceSnapshotFile(entry)) {
+            throw new Error(`Skill patch file ${filePath} files[${index}] must be an object with string path and content fields, got: ${describePatchEntry(entry)}.`);
+        }
+        return {
+            ...entry,
+            path: normalizeRelativePath(entry.path),
+        };
+    });
+    if (record.fileChanges !== undefined && !Array.isArray(record.fileChanges)) {
+        throw new Error(`Skill patch file ${filePath} fileChanges must be an array of strings when provided.`);
+    }
+    const fileChanges = Array.isArray(record.fileChanges)
+        ? record.fileChanges.map((entry, index) => {
+            if (typeof entry !== "string") {
+                throw new Error(`Skill patch file ${filePath} fileChanges[${index}] must be a string path, got: ${describePatchEntry(entry)}.`);
+            }
+            return normalizeRelativePath(entry);
+        })
+        : files.map((file) => file.path);
+    return {
+        files,
+        fileChanges,
+        ...(typeof record.summary === "string" ? { summary: record.summary } : {}),
+        ...(record.feedback !== undefined ? { feedback: record.feedback } : {}),
+    };
+}
+function describePatchEntry(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "an array";
+    }
+    if (typeof value === "object") {
+        const record = value;
+        const keys = Object.keys(record);
+        return `an object with key${keys.length === 1 ? "" : "s"} [${keys.join(", ")}]`;
+    }
+    return `a ${typeof value}`;
+}
+function isPatchSurfaceSnapshotFile(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return typeof record.path === "string" && typeof record.content === "string";
+}
 async function writeOperationOkUnlessPresent(request, beforeRoot) {
     if (await fileExists(workbenchAdapterOperationResultPath(request.paths.output))) {
         return;
     }
-    if (request.operation === "candidate.improve") {
-        const patch = await createCandidatePatchFromWorkspace({
-            beforeRoot: beforeRoot ?? requiredRequestPath(request.paths.candidate, "paths.candidate"),
-            afterRoot: request.paths.workspace,
-            edits: request.context?.improve?.edits ?? [],
-        });
+    if (request.operation === "skill.improve") {
+        const skillRoot = requiredRequestPath(request.paths.skill, "paths.skill");
+        const patch = await readSkillPatchFile(commandSkillPatchPath(request)) ??
+            await createSkillPatchFromWorkspace({
+                beforeRoot: beforeRoot ?? skillRoot,
+                afterRoot: skillRoot,
+                edits: request.context?.improve?.edits ?? [],
+            });
         await writeWorkbenchAdapterOperationResult(request.paths.output, {
             protocol: "workbench.adapter-result.v1",
             operation: request.operation,
@@ -411,10 +343,10 @@ async function writeOperationOkUnlessPresent(request, beforeRoot) {
         ok: true,
     });
 }
-async function snapshotEditableCandidateWorkspace(request) {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), "workbench-candidate-before-"));
+async function snapshotEditableSkillWorkspace(request) {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "workbench-skill-before-"));
     const edits = request.context?.improve?.edits ?? [];
-    const files = await readEditableCandidateWorkspaceFiles(request.paths.workspace, edits);
+    const files = await readEditableSkillWorkspaceFiles(requiredRequestPath(request.paths.skill, "paths.skill"), edits);
     await writeSurfaceFiles(root, files);
     return {
         root,
@@ -423,7 +355,7 @@ async function snapshotEditableCandidateWorkspace(request) {
         },
     };
 }
-async function readEditableCandidateWorkspaceFiles(root, edits) {
+async function readEditableSkillWorkspaceFiles(root, edits) {
     const editPaths = edits
         .map(normalizeRelativePath)
         .filter((filePath) => !isRuntimeWorkspacePath(filePath));
@@ -431,7 +363,7 @@ async function readEditableCandidateWorkspaceFiles(root, edits) {
         return [];
     }
     const files = await readSurfaceFiles(root);
-    return dedupeSurfaceFiles(files.filter((file) => isCandidateEditPath(file.path, editPaths) &&
+    return dedupeSurfaceFiles(files.filter((file) => isAllowedSkillEditPath(file.path, editPaths) &&
         !isRuntimeWorkspacePath(file.path)));
 }
 async function firstExistingFile(files) {
@@ -449,64 +381,63 @@ function requiredRequestPath(value, label) {
     }
     return value;
 }
-async function readEngineCasesFromWorkbenchTaskRoot(tasksRoot) {
-    const taskDirs = await listWorkbenchTaskDirectories(tasksRoot);
-    if (taskDirs.length === 0) {
-        throw new Error(`Engine resolve has no Workbench task packages: ${tasksRoot}`);
+async function readEngineCasesFromWorkbenchCaseRoot(casesRoot) {
+    const caseDirs = await listWorkbenchCaseDirectories(casesRoot);
+    if (caseDirs.length === 0) {
+        throw new Error(`Engine resolve has no Workbench case packages: ${casesRoot}`);
     }
-    return await Promise.all(taskDirs.map(async (taskDir) => readWorkbenchEngineCase({
-        taskDir,
-        id: path.basename(taskDir),
+    return await Promise.all(caseDirs.map(async (caseDir) => readWorkbenchEngineCase({
+        caseDir,
+        id: path.basename(caseDir),
     })));
 }
-async function listWorkbenchTaskDirectories(root) {
-    if (await fileExists(path.join(root, TASK_CONTROL_FILE))) {
-        throw new Error(`Workbench engine tasks root must contain task directories, not a direct ${TASK_CONTROL_FILE}: ${root}`);
+async function listWorkbenchCaseDirectories(root) {
+    if (await fileExists(path.join(root, CASE_CONTROL_FILE))) {
+        throw new Error(`Workbench engine cases root must contain case directories, not a direct ${CASE_CONTROL_FILE}: ${root}`);
     }
     const entries = await fs.readdir(root, { withFileTypes: true });
-    const tasks = [];
+    const cases = [];
     for (const entry of entries) {
         if (!entry.isDirectory()) {
             continue;
         }
-        const taskDir = path.join(root, entry.name);
-        if (await fileExists(path.join(taskDir, TASK_CONTROL_FILE))) {
-            tasks.push(taskDir);
+        const caseDir = path.join(root, entry.name);
+        if (await fileExists(path.join(caseDir, CASE_CONTROL_FILE))) {
+            cases.push(caseDir);
         }
     }
-    return tasks.sort((left, right) => left.localeCompare(right));
+    return cases.sort((left, right) => left.localeCompare(right));
 }
 async function readWorkbenchEngineCase(args) {
-    const sourceFiles = await readSurfaceFiles(args.taskDir);
-    const taskFile = sourceFiles.find((file) => normalizeRelativePath(file.path) === TASK_CONTROL_FILE && file.encoding === "utf8");
-    if (!taskFile) {
-        throw new Error(`Task ${args.id} is missing ${TASK_CONTROL_FILE}.`);
-    }
-    const parsed = YAML.parse(taskFile.content);
-    const taskRecord = jsonRecord(parsed);
-    if (taskRecord.version !== 3) {
-        throw new Error(`Task ${args.id} ${TASK_CONTROL_FILE} version must be 3.`);
-    }
-    if (typeof taskRecord.task !== "string" || taskRecord.task.trim().length === 0) {
-        throw new Error(`Task ${args.id} ${TASK_CONTROL_FILE} must include a task string.`);
-    }
-    const unsupportedTaskFields = Object.keys(taskRecord)
-        .filter((key) => !["version", "task", "split", "files", "tests", "solution", "environment"].includes(key));
-    if (unsupportedTaskFields.length > 0) {
-        throw new Error(`Task ${args.id} ${TASK_CONTROL_FILE} has unsupported field${unsupportedTaskFields.length === 1 ? "" : "s"}: ${unsupportedTaskFields.join(", ")}.`);
-    }
-    if (taskRecord.split !== undefined && (typeof taskRecord.split !== "string" || taskRecord.split.trim().length === 0)) {
-        throw new Error(`Task ${args.id} ${TASK_CONTROL_FILE} split must be a non-empty string when provided.`);
-    }
-    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 publicFiles = stripTaskDirectory(sourceFiles, publicPrefix);
+    const sourceFiles = await readSurfaceFiles(args.caseDir);
+    const caseFile = sourceFiles.find((file) => normalizeRelativePath(file.path) === CASE_CONTROL_FILE && file.encoding === "utf8");
+    if (!caseFile) {
+        throw new Error(`Case ${args.id} is missing ${CASE_CONTROL_FILE}.`);
+    }
+    const caseRecord = jsonRecord(YAML.parse(caseFile.content));
+    if (caseRecord.version !== 1) {
+        throw new Error(`Case ${args.id} ${CASE_CONTROL_FILE} version must be 1.`);
+    }
+    if (typeof caseRecord.case !== "string" || caseRecord.case.trim().length === 0) {
+        throw new Error(`Case ${args.id} ${CASE_CONTROL_FILE} must include a case string.`);
+    }
+    const unsupportedCaseFields = Object.keys(caseRecord)
+        .filter((key) => !["version", "case", "split", "files", "tests", "solution", "environment"].includes(key));
+    if (unsupportedCaseFields.length > 0) {
+        throw new Error(`Case ${args.id} ${CASE_CONTROL_FILE} has unsupported field${unsupportedCaseFields.length === 1 ? "" : "s"}: ${unsupportedCaseFields.join(", ")}.`);
+    }
+    if (caseRecord.split !== undefined && (typeof caseRecord.split !== "string" || caseRecord.split.trim().length === 0)) {
+        throw new Error(`Case ${args.id} ${CASE_CONTROL_FILE} split must be a non-empty string when provided.`);
+    }
+    const publicPrefix = caseDirectoryPrefix(caseRecord.files, "files", args.id);
+    const testsPrefix = caseDirectoryPrefix(caseRecord.tests, "tests", args.id);
+    const solutionPrefix = caseDirectoryPrefix(caseRecord.solution, "solution", args.id);
+    const publicFiles = stripCaseDirectory(sourceFiles, publicPrefix);
     const privateFiles = [
-        ...stripTaskDirectory(sourceFiles, testsPrefix),
-        ...stripTaskDirectory(sourceFiles, solutionPrefix),
+        ...stripCaseDirectory(sourceFiles, testsPrefix),
+        ...stripCaseDirectory(sourceFiles, solutionPrefix),
     ].sort((left, right) => left.path.localeCompare(right.path));
-    assertWorkbenchTaskPackageLayout(args.id, sourceFiles, [
+    assertWorkbenchCasePackageLayout(args.id, sourceFiles, [
         publicPrefix,
         testsPrefix,
         solutionPrefix,
@@ -516,10 +447,10 @@ async function readWorkbenchEngineCase(args) {
         id: normalizeRelativePath(args.id),
         case: {
             version: 3,
-            prompt: taskRecord.task,
-            ...(typeof taskRecord.split === "string" ? { split: taskRecord.split.trim() } : {}),
-            ...(taskRecord.environment !== undefined
-                ? { environment: taskRecord.environment }
+            prompt: caseRecord.case,
+            ...(typeof caseRecord.split === "string" ? { split: caseRecord.split.trim() } : {}),
+            ...(caseRecord.environment !== undefined
+                ? { environment: caseRecord.environment }
                 : {}),
         },
         files: {
@@ -529,26 +460,26 @@ async function readWorkbenchEngineCase(args) {
         },
     };
 }
-function taskDirectoryPrefix(value, fallback, taskId) {
+function caseDirectoryPrefix(value, fallback, caseId) {
     if (value === undefined) {
         return `${fallback}/`;
     }
     const record = jsonRecord(value);
     if (typeof record.path !== "string" || record.path.trim().length === 0) {
-        throw new Error(`Task ${taskId} ${TASK_CONTROL_FILE} path config must include a path string.`);
+        throw new Error(`Case ${caseId} ${CASE_CONTROL_FILE} path config must include a path string.`);
     }
     return `${normalizeRelativePath(record.path)}/`;
 }
-function assertWorkbenchTaskPackageLayout(taskId, files, allowedPrefixes) {
+function assertWorkbenchCasePackageLayout(caseId, files, allowedPrefixes) {
     const invalid = files
         .map((file) => normalizeRelativePath(file.path))
-        .filter((filePath) => filePath !== TASK_CONTROL_FILE &&
+        .filter((filePath) => filePath !== CASE_CONTROL_FILE &&
         !allowedPrefixes.some((prefix) => filePath.startsWith(prefix)));
     if (invalid.length > 0) {
-        throw new Error(`Task ${taskId} contains unsupported file${invalid.length === 1 ? "" : "s"} outside task.yaml or declared task directories: ${invalid.join(", ")}`);
+        throw new Error(`Case ${caseId} contains unsupported file${invalid.length === 1 ? "" : "s"} outside case.yaml or declared case directories: ${invalid.join(", ")}`);
     }
 }
-function stripTaskDirectory(files, prefix) {
+function stripCaseDirectory(files, prefix) {
     return files.flatMap((file) => {
         const normalized = normalizeRelativePath(file.path);
         if (!normalized.startsWith(prefix)) {
@@ -578,7 +509,9 @@ async function readTestsResult(args) {
         }
         return normalizeTestsResult({ reward: score }, args.caseId);
     }
-    throw new Error("Tests engine did not find reward.json or reward.txt under its verifier output directory.");
+    throw new Error("Tests engine did not find reward.json or reward.txt under its verifier output directory " +
+        `(${args.verifierRoot}). The tests script must write a reward to ` +
+        "$WORKBENCH_TESTS_VERIFIER_DIR/reward.json or $WORKBENCH_TESTS_VERIFIER_DIR/reward.txt.");
 }
 function testsVerifierOutputDir(outputRoot) {
     return path.join(outputRoot, ".workbench", "internal", "verifier");
@@ -643,17 +576,17 @@ function workloadFromAdapterOperationRequest(request) {
     const attempt = context.attempt ?? {};
     return {
         job: { id: request.jobId ?? request.id },
-        benchmark: {
-            name: context.benchmark?.name ?? "",
-            description: context.benchmark?.description ?? "",
+        eval: {
+            name: context.eval?.name ?? "",
+            description: context.eval?.description ?? "",
         },
-        candidate: {
-            path: context.candidate?.path ?? "",
+        skill: {
+            path: context.skill?.path ?? "",
         },
         improve: {
             edits: context.improve?.edits ?? [],
         },
-        candidateId: context.candidate?.id ?? "",
+        versionId: context.skill?.id ?? "",
         attemptIndex: attempt.attemptIndex ?? 0,
         sampleIndex: attempt.sampleIndex ?? 0,
         caseId: attempt.caseId ?? "",
@@ -725,39 +658,53 @@ function requiredAdapterCommandString(request, key) {
     }
     return value;
 }
+function eventPublisherForAdapterRequest(request) {
+    if (!request.progress) {
+        return undefined;
+    }
+    return createWorkbenchExecutionEventPublisher({
+        projectId: request.progress.projectId,
+        runId: request.progress.runId,
+        jobId: request.progress.jobId,
+        executionId: request.progress.executionId,
+        attempt: request.progress.attempt,
+        target: request.progress.target,
+    });
+}
 async function executeBuiltInAgentTurn(executor, request) {
     const { defaultWorkbenchAgentTurnExecutor, executeWorkbenchAgentTurn, } = await import("./agent-turn.js");
     return await executeWorkbenchAgentTurn(executor ?? defaultWorkbenchAgentTurnExecutor, request);
 }
-async function writeAgentCandidateOutput(request, workload, candidate, options = {}) {
-    if (request.operation !== "candidate.run") {
-        throw new Error("Agent candidate results can only complete candidate.run operations.");
+async function writeAgentSkillOutput(request, workload, adapter, options = {}) {
+    if (request.operation !== "skill.run") {
+        throw new Error("Agent skill execution results can only complete skill.run operations.");
     }
-    const traceRoot = path.join(request.paths.output, ".workbench", "internal", "agent-candidate");
+    const traceRoot = path.join(request.paths.output, ".workbench", "internal", "agent-skill");
     const agentResult = await executeBuiltInAgentTurn(options.agentExecutor, {
         role: "runner",
-        provider: candidate.agent,
+        provider: adapter.agent,
         adapterAuthRoot: options.adapterAuthRoot,
         adapterAuthRequest: options.adapterAuthRequest,
         adapterAuthEnv: options.adapterAuthEnv,
         workspaceRoot: request.paths.workspace,
         cwd: request.paths.workspace,
-        prompt: buildAgentCandidatePrompt(workload, candidate),
+        prompt: buildAgentSkillPrompt(workload, adapter),
         traceRoot,
         jobId: workload.job.id,
+        eventPublisher: options.eventPublisher,
     });
-    const outputPath = path.join(request.paths.output, "candidate-summary.md");
+    const outputPath = path.join(request.paths.output, "skill-summary.md");
     await fs.mkdir(path.dirname(outputPath), { recursive: true });
     await fs.writeFile(outputPath, agentResult.output);
     const trace = {
-        path: `.workbench/traces/${workload.job.id}/candidate.json`,
+        path: `.workbench/traces/${workload.job.id}/skill.json`,
         kind: "text",
         encoding: "utf8",
         executable: false,
         content: `${JSON.stringify({
-            kind: "agent_candidate",
-            provider: candidate.agent.use,
-            candidateId: workload.candidateId,
+            kind: "agent_skill",
+            provider: adapter.agent.use,
+            versionId: workload.versionId,
             attemptIndex: workload.attemptIndex,
             sampleIndex: workload.sampleIndex,
             summary: agentResult.output,
@@ -769,37 +716,37 @@ async function writeAgentCandidateOutput(request, workload, candidate, options =
     const usage = runtime.assignUsageRole("runner", agentResult.usage);
     await writeWorkbenchAdapterOperationResult(request.paths.output, {
         protocol: "workbench.adapter-result.v1",
-        operation: "candidate.run",
+        operation: "skill.run",
         ok: true,
         ...(agentResult.output ? { summary: agentResult.output } : {}),
         feedback: {
-            candidate: "agent",
-            agent: candidate.agent.use,
+            skill: "agent",
+            agent: adapter.agent.use,
             metadata: agentResult.metadata,
         },
         ...(usage ? { usage } : {}),
     });
 }
-function buildAgentCandidatePrompt(workload, candidate) {
+function buildAgentSkillPrompt(workload, adapter) {
     return [
-        ...(candidate.instructions ? ["Instructions:", candidate.instructions, ""] : []),
+        ...(adapter.instructions ? ["Instructions:", adapter.instructions, ""] : []),
         "Context:",
-        "- Candidate source files are mounted at /workspace/input/candidate.",
-        "- Follow any candidate guidance, skill files, scripts, or configuration under /workspace/input/candidate.",
+        "- The entry skill is mounted at /workspace/input/skills/primary unless another skill is selected.",
+        "- All skills installed for this run are mounted under /workspace/input/skills.",
         "- The mutable working directory is /workspace.",
-        "- If the candidate declares prepare.command, it has already run and may have copied files into /workspace.",
+        "- If the skill 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.",
-        "- Mutate the current working directory to complete the task.",
+        "- Mutate the current working directory to complete the case.",
         "- You may write inspection artifacts under /workspace/output.",
     ].join("\n");
 }
-async function writeAgentCandidateRevisionOutput(request, workload, improver, options) {
-    if (request.operation !== "candidate.improve") {
-        throw new Error("Agent improve results can only complete candidate.improve operations.");
+async function writeAgentSkillRevisionOutput(request, workload, improver, options) {
+    if (request.operation !== "skill.improve") {
+        throw new Error("Agent skill improvement results can only complete skill.improve operations.");
     }
-    const before = await snapshotEditableCandidateWorkspace(request);
+    const before = await snapshotEditableSkillWorkspace(request);
     const traceRoot = path.join(request.paths.output, ".workbench", "internal", "agent-improver");
     try {
         const agentResult = await executeBuiltInAgentTurn(options.agentExecutor, {
@@ -809,19 +756,20 @@ async function writeAgentCandidateRevisionOutput(request, workload, improver, op
             adapterAuthRequest: options.adapterAuthRequest,
             adapterAuthEnv: options.adapterAuthEnv,
             workspaceRoot: request.paths.workspace,
-            cwd: request.paths.workspace,
+            cwd: requiredRequestPath(request.paths.skill, "paths.skill"),
             prompt: buildAgentImproverPrompt(workload),
             traceRoot,
             jobId: workload.job.id,
+            eventPublisher: options.eventPublisher,
         });
-        const candidatePatch = await createCandidatePatchFromWorkspace({
+        const skillPatch = await createSkillPatchFromWorkspace({
             beforeRoot: before.root,
-            afterRoot: request.paths.workspace,
+            afterRoot: requiredRequestPath(request.paths.skill, "paths.skill"),
             edits: workload.improve.edits,
         });
-        const changedCandidatePaths = candidatePatch.fileChanges.filter((filePath) => isCandidateEditPath(filePath, workload.improve.edits));
-        if (changedCandidatePaths.length === 0) {
-            throw new Error("Agent improve adapter completed without changing a candidate file covered by improve edits.");
+        const changedSkillPaths = skillPatch.fileChanges.filter((filePath) => isAllowedSkillEditPath(filePath, workload.improve.edits));
+        if (changedSkillPaths.length === 0) {
+            throw new Error("Agent improve adapter completed without changing a skill file covered by improve edits.");
         }
         const trace = {
             path: `.workbench/traces/${workload.job.id}/improver.json`,
@@ -831,9 +779,9 @@ async function writeAgentCandidateRevisionOutput(request, workload, improver, op
             content: `${JSON.stringify({
                 kind: "agent_improver",
                 provider: improver.agent.use,
-                candidateId: workload.candidateId,
+                versionId: workload.versionId,
                 attemptIndex: workload.attemptIndex,
-                changedPaths: changedCandidatePaths,
+                changedPaths: changedSkillPaths,
                 summary: agentResult.output,
                 metadata: agentResult.metadata,
             }, null, 2)}\n`,
@@ -843,16 +791,16 @@ async function writeAgentCandidateRevisionOutput(request, workload, improver, op
         const usage = runtime.assignUsageRole("improver", agentResult.usage);
         await writeWorkbenchAdapterOperationResult(request.paths.output, {
             protocol: "workbench.adapter-result.v1",
-            operation: "candidate.improve",
+            operation: "skill.improve",
             ok: true,
             value: {
-                ...candidatePatch,
-                fileChanges: changedCandidatePaths,
+                ...skillPatch,
+                fileChanges: changedSkillPaths,
             },
             ...(agentResult.output ? { summary: agentResult.output } : {}),
             feedback: {
                 improver: improver.agent.use,
-                changedPaths: changedCandidatePaths,
+                changedPaths: changedSkillPaths,
                 metadata: agentResult.metadata,
             },
             ...(usage ? { usage } : {}),
@@ -864,12 +812,12 @@ async function writeAgentCandidateRevisionOutput(request, workload, improver, op
 }
 function buildAgentImproverPrompt(workload) {
     return [
-        "Benchmark:",
-        workload.benchmark.description || workload.benchmark.name,
+        "Eval:",
+        workload.eval.description || workload.eval.name,
         "",
-        "Improve the candidate for this benchmark.",
+        "Improve the skill for this eval.",
         "",
-        "Candidate files are in the current directory.",
+        "Skill files are in the current directory.",
         "Prior adapter executions are in /workspace/input/traces.",
         "",
         "Editable paths:",
@@ -893,6 +841,7 @@ async function writeRubricJudgeResult(request, workload, engine, options = {}) {
         adapterAuthRequest: options.adapterAuthRequest,
         adapterAuthEnv: options.adapterAuthEnv,
         runtime,
+        eventPublisher: options.eventPublisher,
     }));
     const usage = runtime.mergeUsageSummaries(criterionRuns.map((run) => run.usage));
     const result = rubricJudgeResultFromCriteria({
@@ -935,7 +884,7 @@ async function writeRubricEvidenceFiles(args) {
         schema: "workbench.engine.rubric.evidence.v1",
         safeForImprover: true,
         jobId: args.workload.job.id,
-        candidateId: args.workload.candidateId,
+        versionId: args.workload.versionId,
         attemptIndex: args.workload.attemptIndex,
         sampleIndex: args.workload.sampleIndex,
         caseId: args.workload.caseId,
@@ -1011,6 +960,7 @@ async function runRubricCriterionJudge(args) {
         traceRoot: path.join(traceRoot, "judge"),
         tracePath,
         jobId: args.workload.job.id,
+        eventPublisher: args.eventPublisher,
     });
     let usage = args.runtime.assignUsageRole("engine", agentResult.usage);
     try {
@@ -1040,6 +990,7 @@ async function runRubricCriterionJudge(args) {
             traceRoot: path.join(traceRoot, "repair"),
             tracePath: repairTracePath,
             jobId: args.workload.job.id,
+            eventPublisher: args.eventPublisher,
         });
         usage = args.runtime.mergeUsageSummaries([
             usage,
@@ -1076,7 +1027,7 @@ function rubricCriterionTracePath(jobId, criterionId, turn) {
     return `.workbench/traces/${jobId}/engine/rubric/criteria/${safeInternalPathSegment(criterionId)}/${turn}`;
 }
 function buildRubricCriterionJudgePrompt(workload, engine, criterion) {
-    requireWorkloadTask(workload, "Rubric judge");
+    requireWorkloadCase(workload, "Rubric judge");
     return [
         ...(engine.instructions ? ["Instructions:", engine.instructions, ""] : []),
         ...(workload.case?.prompt ? ["Case:", workload.case.prompt, ""] : []),
@@ -1084,10 +1035,10 @@ function buildRubricCriterionJudgePrompt(workload, engine, criterion) {
         JSON.stringify(criterion, null, 2),
         "",
         "Context:",
-        "- The candidate already ran in this same working directory.",
-        "- Candidate outputs are available in the current working directory.",
+        "- The skill already ran in this same working directory.",
+        "- Skill outputs are available in the current working directory.",
         "- Public case files are mounted at /workspace/input/case.",
-        "- Verifier-private files are mounted at /workspace/private/engine when the task provides them.",
+        "- Verifier-private files are mounted at /workspace/private/engine when the case provides them.",
         "- Score only from the current working directory, public case files, verifier-private files, and the criterion above.",
         "",
         "Output:",
@@ -1276,17 +1227,17 @@ async function mapWithConcurrency(inputs, concurrency, mapper) {
     await Promise.all(Array.from({ length: limit }, async () => worker()));
     return results;
 }
-function requireWorkloadTask(workload, label) {
+function requireWorkloadCase(workload, label) {
     if (!workload.case) {
         throw new Error(`${label} workload is missing case text.`);
     }
 }
-async function createCandidatePatchFromWorkspace(args) {
+async function createSkillPatchFromWorkspace(args) {
     const before = new Map((await readSurfaceFiles(args.beforeRoot))
         .map((file) => [normalizeRelativePath(file.path), file]));
     const changedFiles = (await readSurfaceFiles(args.afterRoot))
         .map((file) => ({ ...file, path: normalizeRelativePath(file.path) }))
-        .filter((file) => isCandidateEditPath(file.path, args.edits) &&
+        .filter((file) => isAllowedSkillEditPath(file.path, args.edits) &&
         !isRuntimeWorkspacePath(file.path) &&
         !sameSurfaceFile(before.get(file.path), file))
         .sort((left, right) => left.path.localeCompare(right.path));
@@ -1313,7 +1264,7 @@ function isRuntimeWorkspacePath(filePath) {
         normalized === "private" ||
         normalized.startsWith("private/");
 }
-function isCandidateEditPath(filePath, edits) {
+function isAllowedSkillEditPath(filePath, edits) {
     const normalized = normalizeRelativePath(filePath);
     return edits.some((entry) => {
         const editPath = normalizeRelativePath(entry).replace(/\/+$/u, "");

package/dist/manifests.d.ts

@@ -1,9 +1,2 @@
-import type { WorkbenchAdapterManifest } from "@workbench-ai/workbench-protocol";
-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;
-export declare function builtinWorkbenchAdapterManifests(): WorkbenchAdapterManifest[];
-export declare function isWorkbenchBuiltInAdapterId(id: string): id is WorkbenchBuiltInAdapterId;
-export declare function adapterCommandName(adapterId: string): string;
+export { adapterCommandName, builtinWorkbenchAdapterManifest, builtinWorkbenchAdapterManifests, isWorkbenchBuiltInAdapterId, type WorkbenchBuiltInAdapterId, type WorkbenchEngineHelperAdapterId, type WorkbenchPublicBuiltInAdapterId, } from "@workbench-ai/workbench-protocol";
 //# sourceMappingURL=manifests.d.ts.map

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,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"}
+{"version":3,"file":"manifests.d.ts","sourceRoot":"","sources":["../src/manifests.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,+BAA+B,EAC/B,gCAAgC,EAChC,2BAA2B,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,8BAA8B,EACnC,KAAK,+BAA+B,GACrC,MAAM,kCAAkC,CAAC"}

package/dist/manifests.js

@@ -1,100 +1 @@
-import { adapterSlot, defineAdapter, defineEngineResolver, defineCandidate, defineImprover, defineEngineRunner, workbenchAdapterManifestFromDefinition, } from "@workbench-ai/workbench-protocol";
-const BUILT_IN_ADAPTER_MANIFESTS = Object.fromEntries(Object.entries({
-    workbench: defineAdapter({
-        id: "workbench",
-        engineResolve: defineEngineResolver(),
-        engineRun: defineEngineRunner({ executor: "host" }),
-        slots: {
-            score: adapterSlot("/score", "engine.run"),
-        },
-    }),
-    codex: defineAdapter({
-        id: "codex",
-        candidate: defineCandidate(),
-        improve: defineImprover(),
-        setup: [
-            "npm install --global @openai/codex@0.125.0",
-        ],
-        auth: {
-            methods: {
-                oauth: { files: [{ path: ".codex/auth.json" }] },
-                "api-key": { env: [{ name: "OPENAI_API_KEY" }] },
-            },
-        },
-    }),
-    claude: defineAdapter({
-        id: "claude",
-        candidate: defineCandidate(),
-        improve: defineImprover(),
-        setup: [
-            "npm install --global @anthropic-ai/claude-code@2.1.119",
-        ],
-        auth: {
-            methods: {
-                oauth: {
-                    files: [
-                        { path: ".claude.json" },
-                        { path: ".claude/oauth-token", required: false },
-                        { path: ".claude/.credentials.json", required: false },
-                    ],
-                },
-                "api-key": { env: [{ name: "ANTHROPIC_API_KEY" }] },
-                bedrock: {
-                    env: [
-                        { name: "CLAUDE_CODE_USE_BEDROCK" },
-                        { name: "AWS_ACCESS_KEY_ID", required: false },
-                        { name: "AWS_SECRET_ACCESS_KEY", required: false },
-                        { name: "AWS_SESSION_TOKEN", required: false },
-                        { name: "AWS_REGION" },
-                        { name: "AWS_DEFAULT_REGION", required: false },
-                        { name: "AWS_BEARER_TOKEN_BEDROCK", required: false },
-                        { name: "ANTHROPIC_MODEL", required: false },
-                        { name: "ANTHROPIC_SMALL_FAST_MODEL", required: false },
-                    ],
-                },
-            },
-        },
-    }),
-    command: defineAdapter({
-        id: "command",
-        candidate: defineCandidate(),
-        engineRun: defineEngineRunner(),
-        improve: defineImprover(),
-    }),
-    rubric: defineAdapter({
-        id: "rubric",
-        engineRun: defineEngineRunner(),
-        slots: {
-            judge: adapterSlot("/judge", "candidate.run"),
-        },
-    }),
-    tests: defineAdapter({
-        id: "tests",
-        engineRun: defineEngineRunner(),
-    }),
-}).map(([id, definition]) => [id, workbenchAdapterManifestFromDefinition(definition)]));
-export function builtinWorkbenchAdapterManifest(id) {
-    return isWorkbenchBuiltInAdapterId(id)
-        ? cloneManifest(BUILT_IN_ADAPTER_MANIFESTS[id])
-        : null;
-}
-export function builtinWorkbenchAdapterManifests() {
-    return Object.keys(BUILT_IN_ADAPTER_MANIFESTS)
-        .sort()
-        .map((id) => cloneManifest(BUILT_IN_ADAPTER_MANIFESTS[id]));
-}
-export function isWorkbenchBuiltInAdapterId(id) {
-    return Object.prototype.hasOwnProperty.call(BUILT_IN_ADAPTER_MANIFESTS, id);
-}
-export function adapterCommandName(adapterId) {
-    return `workbench-adapter-${adapterId}`;
-}
-function cloneManifest(manifest) {
-    return {
-        ...manifest,
-        operations: JSON.parse(JSON.stringify(manifest.operations)),
-        setup: [...manifest.setup],
-        ...(manifest.auth ? { auth: JSON.parse(JSON.stringify(manifest.auth)) } : {}),
-        ...(manifest.slots ? { slots: JSON.parse(JSON.stringify(manifest.slots)) } : {}),
-    };
-}
+export { adapterCommandName, builtinWorkbenchAdapterManifest, builtinWorkbenchAdapterManifests, isWorkbenchBuiltInAdapterId, } from "@workbench-ai/workbench-protocol";

package/dist/runtime.js

@@ -12,11 +12,11 @@ export async function importWorkbenchRuntime() {
     return await runtimeModule;
 }
 async function importWorkbenchRuntimeUncached() {
-    const candidates = runtimeImportCandidates();
+    const specifiers = runtimeImportOptions();
     let lastError;
-    for (const candidate of candidates) {
+    for (const specifier of specifiers) {
         try {
-            return await import(__rewriteRelativeImportExtension(candidate));
+            return await import(__rewriteRelativeImportExtension(specifier));
         }
         catch (error) {
             lastError = error;
@@ -24,11 +24,11 @@ async function importWorkbenchRuntimeUncached() {
     }
     throw new Error(`Unable to load @workbench-ai/workbench-core for built-in adapters: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
 }
-function runtimeImportCandidates() {
+function runtimeImportOptions() {
     return [
         process.env.WORKBENCH_RUNTIME_IMPORT,
         "/app/products/workbench/packages/core/src/index.ts",
         new URL("../../core/src/index.ts", import.meta.url).href,
         "@workbench-ai/workbench-core",
-    ].filter((candidate) => typeof candidate === "string" && candidate.length > 0);
+    ].filter((specifier) => typeof specifier === "string" && specifier.length > 0);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workbench-ai/workbench-built-in-adapters",
-  "version": "0.0.67",
+  "version": "0.0.69",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/workbench-ai/workbench.git",
@@ -32,12 +32,12 @@
   ],
   "dependencies": {
     "yaml": "^2.8.2",
-    "@workbench-ai/agent-driver-anthropic-claude-code": "0.0.46",
-    "@workbench-ai/workbench-contract": "0.0.67",
-    "@workbench-ai/agent-driver": "0.0.46",
     "@workbench-ai/agent-driver-openai-codex": "0.0.46",
-    "@workbench-ai/workbench-core": "0.0.67",
-    "@workbench-ai/workbench-protocol": "0.0.67"
+    "@workbench-ai/agent-driver": "0.0.46",
+    "@workbench-ai/workbench-contract": "0.0.69",
+    "@workbench-ai/workbench-protocol": "0.0.69",
+    "@workbench-ai/agent-driver-anthropic-claude-code": "0.0.46",
+    "@workbench-ai/workbench-core": "0.0.69"
   },
   "devDependencies": {
     "@types/node": "^24.3.1",