@workbench-ai/workbench-built-in-adapters 0.0.66 → 0.0.68

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 skill = adapterAuthProviderOption(adapterAuth.request, providerSpec.use) ??
         (provider.manifest.defaults.auth ?? {});
-    const parsed = provider.schemas.auth.safeParse(candidate);
+    const parsed = provider.schemas.auth.safeParse(skill);
     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;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;AAyDD,wBAAsB,qCAAqC,CACzD,IAAI,GAAE,4CAAiD,GACtD,OAAO,CAAC,IAAI,CAAC,CAiDf"}

package/dist/execute.js

@@ -12,7 +12,8 @@ const DIRECT_ADAPTER_HANDLERS = {
     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);
@@ -48,12 +49,12 @@ 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}.`);
@@ -71,13 +72,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",
@@ -114,7 +115,7 @@ async function workbenchEngineOutcomeUsage(outcome) {
     const operationUsage = outcome.usage
         ? undefined
         : runtime.mergeUsageSummaries(outcome.operationResults.map((result) => {
-            if (result.operation === "candidate.run") {
+            if (result.operation === "skill.run") {
                 return runtime.assignUsageRole("runner", result.usage);
             }
             if (result.operation === "engine.run") {
@@ -128,17 +129,17 @@ async function workbenchEngineOutcomeUsage(outcome) {
         : 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 cases = config.cases;
+    if (cases === undefined) {
+        return "cases";
     }
-    const taskConfig = jsonRecord(tasks);
-    if (typeof taskConfig.path === "string" && taskConfig.path.trim().length > 0) {
-        return taskConfig.path;
+    const caseConfig = jsonRecord(cases);
+    if (typeof caseConfig.path === "string" && caseConfig.path.trim().length > 0) {
+        return caseConfig.path;
     }
-    throw new Error("Workbench engine tasks must be an object with path.");
+    throw new Error("Workbench engine cases must be an object with path.");
 }
 function workbenchEngineScoreInvocation(request) {
     const score = jsonRecord(adapterCommandConfigRecord(request).score);
@@ -154,16 +155,16 @@ function workbenchEngineScoreInvocation(request) {
             : 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.");
+function workbenchEngineSkillInvocation(request) {
+    const skill = request.context?.skill?.run;
+    if (!skill?.use || !skill.command) {
+        throw new Error("Workbench engine requires context.skill.run.use and context.skill.run.command.");
     }
     return {
-        use: candidate.use,
-        with: (candidate.with ?? {}),
-        ...(candidate.auth !== undefined ? { auth: candidate.auth } : {}),
-        command: candidate.command,
+        use: skill.use,
+        with: (skill.with ?? {}),
+        ...(skill.auth !== undefined ? { auth: skill.auth } : {}),
+        command: skill.command,
     };
 }
 async function workbenchEngineGradingIsolation(request) {
@@ -188,13 +189,13 @@ async function workbenchEnginePrivateFilesPresent(request) {
 }
 async function runWorkbenchEngineSharedGrading(request) {
     const inputs = await workbenchEngineRuntimeInputs(request);
-    const candidate = workbenchEngineCandidateInvocation(request);
+    const skill = workbenchEngineSkillInvocation(request);
     const score = workbenchEngineScoreInvocation(request);
     const result = await runWorkbenchRuntimeOperationSequence({
         inputs,
         prepare: true,
         operations: [
-            { label: "candidate", operation: "candidate.run", invocation: candidate },
+            { label: "skill", operation: "skill.run", invocation: skill },
             { label: "score", operation: "engine.run", invocation: score },
         ],
     });
@@ -203,25 +204,25 @@ async function runWorkbenchEngineSharedGrading(request) {
 }
 async function runWorkbenchEngineSeparateGrading(request) {
     const inputs = await workbenchEngineRuntimeInputs(request);
-    const candidate = workbenchEngineCandidateInvocation(request);
+    const skill = workbenchEngineSkillInvocation(request);
     const score = workbenchEngineScoreInvocation(request);
     const runtime = await importWorkbenchRuntime();
     const runner = await runWorkbenchRuntimeOperationSequence({
         inputs: {
-            candidate: inputs.candidate,
+            skill: inputs.skill,
             case: inputs.case,
             traces: inputs.traces,
         },
         prepare: true,
         collectWorkspace: true,
         operations: [
-            { label: "candidate", operation: "candidate.run", invocation: candidate },
+            { label: "skill", operation: "skill.run", invocation: skill },
         ],
     });
     assertRuntimeControlResultOk(runner, "Workbench separate runner");
     const grader = await runWorkbenchRuntimeOperationSequence({
         inputs: {
-            candidate: inputs.candidate,
+            skill: inputs.skill,
             case: inputs.case,
             enginePrivate: inputs.enginePrivate,
             traces: inputs.traces,
@@ -243,14 +244,14 @@ async function runWorkbenchEngineSeparateGrading(request) {
     };
 }
 async function workbenchEngineRuntimeInputs(request) {
-    const [candidate, caseFiles, enginePrivate, traces] = await Promise.all([
-        readOptionalSurfaceFiles(request.paths.candidate),
+    const [skill, caseFiles, enginePrivate, traces] = await Promise.all([
+        readOptionalSurfaceFiles(request.paths.skills ?? request.paths.skill),
         readOptionalSurfaceFiles(request.paths.case),
         readOptionalSurfaceFiles(request.paths.enginePrivate),
         readOptionalSurfaceFiles(request.paths.traces),
     ]);
     return {
-        candidate,
+        skill,
         case: caseFiles,
         enginePrivate,
         traces,
@@ -309,11 +310,11 @@ function safeInternalPathSegment(value) {
 }
 async function executeCommandAdapterRequest(request) {
     const command = requiredAdapterCommandString(request, "command");
-    const before = request.operation === "candidate.improve"
-        ? await snapshotEditableCandidateWorkspace(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;
@@ -343,11 +344,17 @@ async function executeTestsEngineRequest(request) {
     const script = await firstExistingFile([
         path.join(testsRoot, "test.sh"),
         path.join(testsRoot, "run.sh"),
+        path.join(testsRoot, "tests", "test.sh"),
+        path.join(testsRoot, "tests", "run.sh"),
     ]);
     if (!script) {
         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,
     });
     const result = await readTestsResult({
@@ -387,16 +394,68 @@ 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),
+    };
+}
+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.flatMap((entry) => {
+        if (!isPatchSurfaceSnapshotFile(entry)) {
+            return [];
+        }
+        return [{
+                ...entry,
+                path: normalizeRelativePath(entry.path),
+            }];
+    });
+    const fileChanges = Array.isArray(record.fileChanges)
+        ? record.fileChanges.flatMap((entry) => typeof entry === "string" ? [normalizeRelativePath(entry)] : [])
+        : files.map((file) => file.path);
+    return {
+        files,
+        fileChanges,
+        ...(typeof record.summary === "string" ? { summary: record.summary } : {}),
+        ...(record.feedback !== undefined ? { feedback: record.feedback } : {}),
+    };
+}
+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 +470,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 +482,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 +490,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 +508,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 +574,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 +587,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 +636,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 its verifier output directory.");
+    return normalizeTestsResult({
+        score: 1,
+        summary: "Tests passed.",
+    }, args.caseId);
 }
 function testsVerifierOutputDir(outputRoot) {
     return path.join(outputRoot, ".workbench", "internal", "verifier");
@@ -643,17 +704,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 ?? "",
@@ -729,35 +790,35 @@ 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,
     });
-    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 +830,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 +870,19 @@ 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,
         });
-        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 +892,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 +904,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 +925,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:",
@@ -935,7 +996,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,
@@ -1076,7 +1137,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 +1145,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 +1337,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 +1374,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 skills = runtimeImportOptions();
     let lastError;
-    for (const candidate of candidates) {
+    for (const skill of skills) {
         try {
-            return await import(__rewriteRelativeImportExtension(candidate));
+            return await import(__rewriteRelativeImportExtension(skill));
         }
         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((skill) => typeof skill === "string" && skill.length > 0);
 }

package/package.json

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