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

package/dist/execute.js

@@ -0,0 +1,1336 @@
+import { spawn } from "node:child_process";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { ensureWorkbenchAdapterOutputDir, readWorkbenchAdapterOperationResult, readWorkbenchAdapterOperationRequest, writeWorkbenchAdapterOperationResult, workbenchAdapterOperationResultPath, } from "@workbench-ai/workbench-protocol";
+import YAML from "yaml";
+import { isWorkbenchBuiltInAdapterId, adapterCommandName, } from "./manifests.js";
+import { importWorkbenchRuntime } from "./runtime.js";
+const TASK_CONTROL_FILE = "task.yaml";
+const DEFAULT_RUBRIC_PARALLELISM = 4;
+export async function executeWorkbenchBuiltInAdapterCommand(args = {}) {
+    const request = await readWorkbenchAdapterOperationRequest(args.requestPath);
+    const adapterId = args.adapterId ?? request.invocation.use;
+    if (adapterId !== request.invocation.use) {
+        throw new Error(`Adapter command ${adapterId} cannot execute request for ${request.invocation.use}.`);
+    }
+    if (!isWorkbenchBuiltInAdapterId(adapterId)) {
+        throw new Error(`Unsupported built-in Workbench adapter: ${adapterId}.`);
+    }
+    if (args.outputRoot && args.outputRoot !== request.paths.output) {
+        request.paths.output = args.outputRoot;
+    }
+    await ensureWorkbenchAdapterOutputDir(request);
+    if (adapterId === "workbench") {
+        await executeWorkbenchEngineRequest(request);
+        return;
+    }
+    if (adapterId === "command") {
+        await executeCommandAdapterRequest(request);
+        return;
+    }
+    if (adapterId === "tests") {
+        await executeTestsEngineRequest(request);
+        return;
+    }
+    if (adapterId === "rubric") {
+        if (request.operation !== "engine.run") {
+            throw new Error(`Rubric adapter cannot handle ${request.operation}.`);
+        }
+        await writeRubricJudgeResult(request, workloadFromAdapterOperationRequest(request), builtInRubricSpecFromRequest(request), {
+            agentExecutor: args.agentExecutor,
+            adapterAuthRoot: args.adapterAuthRoot,
+            adapterAuthRequest: args.adapterAuthRequest ?? request.auth,
+            adapterAuthEnv: args.adapterAuthEnv,
+        });
+        return;
+    }
+    if (isBuiltInAgentAdapterId(adapterId)) {
+        const workload = workloadFromAdapterOperationRequest(request);
+        const agent = builtInAgentSpecFromRequest(request);
+        if (request.operation === "optimizer.improve") {
+            await writeAgentSubjectRevisionOutput(request, workload, agent, {
+                agentExecutor: args.agentExecutor,
+                adapterAuthRoot: args.adapterAuthRoot,
+                adapterAuthRequest: args.adapterAuthRequest ?? request.auth,
+                adapterAuthEnv: args.adapterAuthEnv,
+            });
+            return;
+        }
+        if (request.operation === "subject.run") {
+            await writeAgentSubjectOutput(request, workload, agent, {
+                agentExecutor: args.agentExecutor,
+                adapterAuthRoot: args.adapterAuthRoot,
+                adapterAuthRequest: args.adapterAuthRequest ?? request.auth,
+                adapterAuthEnv: args.adapterAuthEnv,
+            });
+            return;
+        }
+        throw new Error(`Agent adapter ${adapterId} cannot handle ${request.operation}.`);
+    }
+}
+async function executeWorkbenchEngineRequest(request) {
+    if (request.operation === "engine.resolve") {
+        await executeWorkbenchEngineResolveRequest(request);
+        return;
+    }
+    if (request.operation === "engine.run") {
+        await executeWorkbenchEngineRunRequest(request);
+        return;
+    }
+    throw new Error(`Workbench engine adapter cannot handle ${request.operation}.`);
+}
+async function executeWorkbenchEngineResolveRequest(request) {
+    const configuredPath = workbenchEngineTasksPath(request);
+    const sourcePath = path.resolve(request.paths.cwd ?? 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}`);
+    }
+    const cases = await readEngineCasesFromWorkbenchTaskRoot(sourcePath);
+    await writeWorkbenchAdapterOperationResult(request.paths.output, {
+        protocol: "workbench.adapter-result.v1",
+        operation: "engine.resolve",
+        ok: true,
+        value: { cases },
+        summary: `Resolved Workbench engine cases from ${configuredPath}.`,
+        feedback: {
+            engineResolve: "workbench",
+            path: configuredPath,
+        },
+    });
+}
+async function executeWorkbenchEngineRunRequest(request) {
+    const enginePrivateFiles = await hideWorkbenchEnginePrivateFiles(request);
+    const subjectResult = await runSubjectFromWorkbenchEngine(request);
+    await stageWorkbenchEngineScoringInputs(request, enginePrivateFiles);
+    const score = workbenchEngineScoreInvocation(request);
+    await runNestedAdapterOperation({
+        parent: request,
+        invocation: score,
+        operation: "engine.run",
+        command: score.command,
+        requestName: "score-request.json",
+    });
+    const engineResult = await readWorkbenchAdapterOperationResult(request.paths.output, "engine.run");
+    const usage = mergeNestedEngineUsage(subjectResult.usage, engineResult.usage);
+    if (usage) {
+        await writeWorkbenchAdapterOperationResult(request.paths.output, {
+            ...engineResult,
+            usage,
+        });
+    }
+}
+async function hideWorkbenchEnginePrivateFiles(request) {
+    if (!request.paths.enginePrivate) {
+        return [];
+    }
+    const files = await readSurfaceFilesRecursive(request.paths.enginePrivate).catch((error) => {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    });
+    await fs.rm(request.paths.enginePrivate, { recursive: true, force: true }).catch(() => undefined);
+    return files;
+}
+async function stageWorkbenchEngineScoringInputs(request, enginePrivateFiles) {
+    if (request.paths.enginePrivate) {
+        await fs.rm(request.paths.enginePrivate, { recursive: true, force: true }).catch(() => undefined);
+        await fs.mkdir(request.paths.enginePrivate, { recursive: true });
+        await writeSurfaceFiles(request.paths.enginePrivate, enginePrivateFiles);
+    }
+    if (request.paths.logs) {
+        const verifierLogs = path.join(request.paths.logs, "verifier");
+        await fs.rm(verifierLogs, { recursive: true, force: true }).catch(() => undefined);
+        await fs.mkdir(verifierLogs, { recursive: true });
+    }
+}
+function workbenchEngineTasksPath(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),
+    };
+}
+async function runSubjectFromWorkbenchEngine(request) {
+    const subject = request.context?.subject?.run;
+    if (!subject?.command) {
+        throw new Error("engine.run request context.subject.run.command is required to invoke the subject.");
+    }
+    const subjectOutput = await runNestedAdapterOperation({
+        parent: request,
+        invocation: {
+            use: subject.use,
+            with: (subject.with ?? {}),
+            ...(subject.auth !== undefined ? { auth: subject.auth } : {}),
+            command: subject.command,
+        },
+        operation: "subject.run",
+        command: subject.command,
+        requestName: "subject-request.json",
+        outputName: "subject-run",
+        visibility: "subject",
+    });
+    const result = await readWorkbenchAdapterOperationResult(subjectOutput, "subject.run");
+    await copySubjectOutputArtifacts(subjectOutput, request.paths.output);
+    return result;
+}
+function mergeNestedEngineUsage(subject, engine) {
+    const usage = {};
+    if (subject?.runner) {
+        usage.runner = subject.runner;
+    }
+    else if (subject?.total) {
+        usage.runner = subject.total;
+    }
+    if (engine?.engine) {
+        usage.engine = engine.engine;
+    }
+    else if (engine?.total) {
+        usage.engine = engine.total;
+    }
+    if (subject?.optimizer) {
+        usage.optimizer = subject.optimizer;
+    }
+    return Object.keys(usage).length > 0 ? usage : undefined;
+}
+async function runNestedAdapterOperation(args) {
+    const internalRoot = path.join(args.parent.paths.output, ".workbench", "internal", args.outputName ?? "engine-slot", safeInternalPathSegment(args.parent.id));
+    const output = args.outputName ? path.join(internalRoot, "output") : args.parent.paths.output;
+    const result = args.outputName
+        ? workbenchAdapterOperationResultPath(output)
+        : args.parent.paths.result;
+    const requestPath = path.join(internalRoot, args.requestName);
+    await fs.mkdir(path.dirname(requestPath), { recursive: true });
+    await fs.mkdir(output, { recursive: true });
+    const nestedPaths = {
+        ...args.parent.paths,
+        output,
+        result,
+    };
+    if (args.visibility === "subject") {
+        delete nestedPaths.enginePrivate;
+    }
+    await fs.writeFile(requestPath, `${JSON.stringify({
+        ...args.parent,
+        id: `${args.parent.id}:${args.invocation.use}:${args.operation}`,
+        operation: args.operation,
+        invocation: {
+            use: args.invocation.use,
+            with: args.invocation.with,
+            ...(args.invocation.auth !== undefined ? { auth: args.invocation.auth } : {}),
+        },
+        ...(args.parent.auth !== undefined
+            ? { auth: adapterScopedAuth(args.parent.auth, args.invocation.use) }
+            : {}),
+        paths: nestedPaths,
+    }, null, 2)}\n`);
+    await runAdapterShellCommand(args.command, args.parent.paths.cwd ?? args.parent.paths.workspace, {
+        WORKBENCH_ADAPTER_REQUEST: requestPath,
+        WORKBENCH_OUTPUT: output,
+        WORKBENCH_RESULT: result,
+    });
+    return output;
+}
+async function copySubjectOutputArtifacts(source, target) {
+    await copyDirectoryEntries(source, target, "");
+}
+async function copyDirectoryEntries(sourceRoot, targetRoot, relativeDir) {
+    const sourceDir = path.join(sourceRoot, relativeDir);
+    const entries = await fs.readdir(sourceDir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        const relativePath = path.join(relativeDir, entry.name);
+        const normalized = normalizeRelativePath(relativePath);
+        if (normalized === "workbench-result.json" || normalized.startsWith(".workbench/internal/")) {
+            continue;
+        }
+        const sourcePath = path.join(sourceRoot, relativePath);
+        const targetPath = path.join(targetRoot, relativePath);
+        if (entry.isDirectory()) {
+            await copyDirectoryEntries(sourceRoot, targetRoot, relativePath);
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        await fs.copyFile(sourcePath, targetPath);
+    }
+}
+function adapterScopedAuth(auth, adapterId) {
+    if (!auth || typeof auth !== "object" || Array.isArray(auth)) {
+        return auth;
+    }
+    const record = JSON.parse(JSON.stringify(auth));
+    const adapters = record.adapters;
+    if (adapters && typeof adapters === "object" && !Array.isArray(adapters)) {
+        const scoped = adapters[adapterId];
+        if (scoped !== undefined) {
+            record.self = scoped;
+        }
+    }
+    return record;
+}
+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");
+    await runAdapterShellCommand(command, request.paths.cwd ?? request.paths.workspace);
+    if (request.operation === "engine.run") {
+        await requireCommandScoreResult(request);
+        return;
+    }
+    await writeOperationOkUnlessPresent(request);
+}
+async function requireCommandScoreResult(request) {
+    if (!await fileExists(workbenchAdapterOperationResultPath(request.paths.output))) {
+        throw new Error("Command engine must write workbench-result.json for engine.run.");
+    }
+    await readWorkbenchAdapterOperationResult(request.paths.output, "engine.run").catch((error) => {
+        throw new Error(`Command engine wrote an invalid workbench-result.json for engine.run: ${error instanceof Error ? error.message : String(error)}`);
+    });
+}
+async function executeTestsEngineRequest(request) {
+    if (request.operation !== "engine.run") {
+        throw new Error(`Tests adapter cannot handle ${request.operation}.`);
+    }
+    const testsRoot = requiredRequestPath(request.paths.enginePrivate, "paths.enginePrivate");
+    const logsRoot = requiredRequestPath(request.paths.logs, "paths.logs");
+    const verifierLogs = path.join(logsRoot, "verifier");
+    await fs.mkdir(verifierLogs, { recursive: true });
+    const script = await firstExistingFile([
+        path.join(testsRoot, "test.sh"),
+        path.join(testsRoot, "run.sh"),
+    ]);
+    if (!script) {
+        throw new Error(`Tests engine requires ${path.join(testsRoot, "test.sh")}.`);
+    }
+    await runAdapterShellCommand(`sh ${shellQuote(script)}`, request.paths.cwd ?? request.paths.workspace);
+    const result = await readTestsResult({
+        logsRoot,
+        caseId: request.context?.attempt?.caseId ?? "current",
+    });
+    await writeWorkbenchAdapterOperationResult(request.paths.output, {
+        protocol: "workbench.adapter-result.v1",
+        operation: "engine.run",
+        ok: true,
+        value: result,
+        ...(typeof result.summary === "string" ? { summary: result.summary } : {}),
+        feedback: {
+            engine: "tests",
+        },
+    });
+}
+async function runAdapterShellCommand(command, cwd, env = {}) {
+    await new Promise((resolve, reject) => {
+        const child = spawn("sh", ["-c", command], {
+            cwd,
+            env: {
+                ...process.env,
+                ...env,
+            },
+            stdio: "inherit",
+        });
+        child.on("error", reject);
+        child.on("exit", (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(code === null
+                ? `Command adapter exited from signal ${signal ?? "unknown"}.`
+                : `Command adapter exited with status ${code}.`));
+        });
+    });
+}
+async function writeOperationOkUnlessPresent(request) {
+    if (await fileExists(workbenchAdapterOperationResultPath(request.paths.output))) {
+        return;
+    }
+    if (request.operation === "optimizer.improve") {
+        const patch = await createSubjectPatchFromWorkspace({
+            beforeRoot: requiredRequestPath(request.paths.subject, "paths.subject"),
+            afterRoot: request.paths.cwd ?? request.paths.workspace,
+            edits: request.context?.optimizer?.edits ?? [],
+        });
+        await writeWorkbenchAdapterOperationResult(request.paths.output, {
+            protocol: "workbench.adapter-result.v1",
+            operation: request.operation,
+            ok: true,
+            value: patch,
+        });
+        return;
+    }
+    await writeWorkbenchAdapterOperationResult(request.paths.output, {
+        protocol: "workbench.adapter-result.v1",
+        operation: request.operation,
+        ok: true,
+    });
+}
+async function firstExistingFile(files) {
+    for (const file of files) {
+        const stat = await fs.stat(file).catch(() => null);
+        if (stat?.isFile()) {
+            return file;
+        }
+    }
+    return null;
+}
+function requiredRequestPath(value, label) {
+    if (!value) {
+        throw new Error(`Adapter request ${label} is required.`);
+    }
+    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}`);
+    }
+    return await Promise.all(taskDirs.map(async (taskDir) => readWorkbenchEngineCase({
+        taskDir,
+        id: path.basename(taskDir),
+    })));
+}
+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}`);
+    }
+    const entries = await fs.readdir(root, { withFileTypes: true });
+    const tasks = [];
+    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);
+        }
+    }
+    return tasks.sort((left, right) => left.localeCompare(right));
+}
+async function readWorkbenchEngineCase(args) {
+    const sourceFiles = await readSurfaceFilesRecursive(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", "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(", ")}.`);
+    }
+    const publicPrefix = taskDirectoryPrefix(taskRecord.files, "files", args.id);
+    const testsPrefix = taskDirectoryPrefix(taskRecord.tests, "tests", args.id);
+    const solutionPrefix = taskDirectoryPrefix(taskRecord.solution, "solution", args.id);
+    const subjectVisible = stripTaskDirectory(sourceFiles, publicPrefix);
+    const enginePrivate = [
+        ...stripTaskDirectory(sourceFiles, testsPrefix),
+        ...stripTaskDirectory(sourceFiles, solutionPrefix),
+    ].sort((left, right) => left.path.localeCompare(right.path));
+    assertWorkbenchTaskPackageLayout(args.id, sourceFiles, [
+        publicPrefix,
+        testsPrefix,
+        solutionPrefix,
+        "environment/",
+    ]);
+    return {
+        id: normalizeRelativePath(args.id),
+        case: {
+            version: 3,
+            prompt: taskRecord.task,
+            ...(taskRecord.environment !== undefined
+                ? { environment: taskRecord.environment }
+                : {}),
+        },
+        files: {
+            subjectVisible,
+            enginePrivate,
+            source: sourceFiles,
+        },
+    };
+}
+function taskDirectoryPrefix(value, fallback, taskId) {
+    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.`);
+    }
+    return `${normalizeRelativePath(record.path)}/`;
+}
+function assertWorkbenchTaskPackageLayout(taskId, files, allowedPrefixes) {
+    const invalid = files
+        .map((file) => normalizeRelativePath(file.path))
+        .filter((filePath) => filePath !== TASK_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(", ")}`);
+    }
+}
+function stripTaskDirectory(files, prefix) {
+    return files.flatMap((file) => {
+        const normalized = normalizeRelativePath(file.path);
+        if (!normalized.startsWith(prefix)) {
+            return [];
+        }
+        return [{ ...file, path: normalized.slice(prefix.length) }];
+    }).sort((left, right) => left.path.localeCompare(right.path));
+}
+async function readSurfaceFilesRecursive(root) {
+    const result = [];
+    await readSurfaceFilesInto(root, "", result);
+    return result.sort((left, right) => left.path.localeCompare(right.path));
+}
+async function readSurfaceFilesInto(root, relativeDir, result) {
+    const entries = await fs.readdir(path.join(root, relativeDir), { withFileTypes: true });
+    for (const entry of entries) {
+        const relativePath = normalizeRelativePath(path.join(relativeDir, entry.name));
+        const absolutePath = path.join(root, relativePath);
+        if (entry.isDirectory()) {
+            await readSurfaceFilesInto(root, relativePath, result);
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        const [body, stat] = await Promise.all([
+            fs.readFile(absolutePath),
+            fs.stat(absolutePath),
+        ]);
+        const text = body.toString("utf8");
+        const isUtf8 = Buffer.from(text, "utf8").equals(body);
+        result.push({
+            path: relativePath,
+            kind: isUtf8 ? "text" : "binary",
+            encoding: isUtf8 ? "utf8" : "base64",
+            content: isUtf8 ? text : body.toString("base64"),
+            executable: (stat.mode & 0o111) !== 0,
+        });
+    }
+}
+async function fileExists(filePath) {
+    return fs.stat(filePath).then((stat) => stat.isFile(), () => false);
+}
+async function readTestsResult(args) {
+    const rewardJson = await readOptionalJson(path.join(args.logsRoot, "verifier", "reward.json"));
+    if (rewardJson) {
+        return normalizeTestsResult(rewardJson, args.caseId);
+    }
+    const rewardText = await fs.readFile(path.join(args.logsRoot, "verifier", "reward.txt"), "utf8").catch((error) => {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    });
+    if (rewardText !== null) {
+        const score = Number.parseFloat(rewardText.trim());
+        if (!Number.isFinite(score)) {
+            throw new Error("Tests engine reward.txt must contain a finite numeric reward.");
+        }
+        return normalizeTestsResult({ reward: score }, args.caseId);
+    }
+    throw new Error("Tests engine did not find reward.json or reward.txt under the request logs verifier directory.");
+}
+async function readOptionalJson(filePath) {
+    const source = await fs.readFile(filePath, "utf8").catch((error) => {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    });
+    if (source === null) {
+        return null;
+    }
+    const parsed = JSON.parse(source);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${filePath} must contain a JSON object.`);
+    }
+    return parsed;
+}
+function normalizeTestsResult(record, caseId) {
+    const rawScore = typeof record.score === "number"
+        ? record.score
+        : typeof record.reward === "number"
+            ? record.reward
+            : undefined;
+    if (rawScore === undefined || !Number.isFinite(rawScore)) {
+        throw new Error("Tests engine reward must include a finite numeric score or reward.");
+    }
+    const metrics = normalizeTestsMetrics(record, rawScore);
+    return {
+        score: rawScore,
+        metrics,
+        cases: [{
+                id: caseId,
+                status: "completed",
+                metrics,
+            }],
+        ...(typeof record.summary === "string" ? { summary: record.summary } : {}),
+        feedback: {
+            reward: record,
+        },
+    };
+}
+function normalizeTestsMetrics(record, score) {
+    const metrics = { score };
+    const source = record.metrics && typeof record.metrics === "object" && !Array.isArray(record.metrics)
+        ? record.metrics
+        : record;
+    for (const [key, value] of Object.entries(source)) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            metrics[key === "reward" ? "score" : key] = value;
+        }
+    }
+    return metrics;
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/gu, "'\\''")}'`;
+}
+function workloadFromAdapterOperationRequest(request) {
+    const context = request.context ?? {};
+    const attempt = context.attempt ?? {};
+    return {
+        job: { id: request.jobId ?? request.id },
+        benchmark: {
+            name: context.benchmark?.name ?? "",
+            description: context.benchmark?.description ?? "",
+        },
+        subject: {
+            path: context.subject?.path ?? "",
+        },
+        optimizer: {
+            edits: context.optimizer?.edits ?? [],
+        },
+        subjectId: context.subject?.id ?? "",
+        attemptIndex: attempt.attemptIndex ?? 0,
+        sampleIndex: attempt.sampleIndex ?? 0,
+        caseId: attempt.caseId ?? "",
+        ...(context.case?.prompt ? { case: { prompt: context.case.prompt } } : {}),
+    };
+}
+function isBuiltInAgentAdapterId(value) {
+    return value === "codex" || value === "claude" || value === "pi";
+}
+function builtInAgentSpecFromRequest(request) {
+    const config = adapterCommandConfigRecord(request);
+    return {
+        agent: agentProviderFromAdapterCommandRequest(request),
+        ...(typeof config.instructions === "string" && config.instructions.length > 0
+            ? { instructions: config.instructions }
+            : {}),
+    };
+}
+function builtInRubricSpecFromRequest(request) {
+    const config = adapterCommandConfigRecord(request);
+    const criteria = rubricCriteria(config.criteria, "adapter.with.criteria");
+    return {
+        judge: rubricJudgeProviderFromAdapterCommandRequest(request),
+        ...(typeof config.instructions === "string" && config.instructions.length > 0
+            ? { instructions: config.instructions }
+            : {}),
+        parallelism: rubricParallelism(config.parallelism, criteria.length),
+        criteria,
+    };
+}
+function agentProviderFromAdapterCommandRequest(request) {
+    const config = adapterCommandConfigRecord(request);
+    return {
+        use: request.invocation.use,
+        ...(typeof config.model === "string" && config.model.length > 0
+            ? { model: config.model }
+            : {}),
+        ...(typeof config.effort === "string" && config.effort.length > 0
+            ? { effort: config.effort }
+            : {}),
+    };
+}
+function rubricJudgeProviderFromAdapterCommandRequest(request) {
+    const judge = jsonRecord(adapterCommandConfigRecord(request).judge);
+    const use = typeof judge?.use === "string" && judge.use.length > 0
+        ? judge.use
+        : "";
+    if (!use) {
+        throw new Error("Rubric adapter requires adapter.with.judge.use.");
+    }
+    const config = jsonRecord(judge?.with) ?? {};
+    return {
+        use,
+        ...(typeof config.model === "string" && config.model.length > 0
+            ? { model: config.model }
+            : {}),
+        ...(typeof config.effort === "string" && config.effort.length > 0
+            ? { effort: config.effort }
+            : {}),
+    };
+}
+function adapterCommandConfigRecord(request) {
+    return jsonRecord(request.invocation.with);
+}
+function requiredAdapterCommandString(request, key) {
+    const value = adapterCommandConfigRecord(request)[key];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Adapter ${request.invocation.use} requires invocation.with.${key}.`);
+    }
+    return value;
+}
+async function executeBuiltInAgentTurn(executor, request) {
+    const { defaultWorkbenchAgentTurnExecutor, executeWorkbenchAgentTurn, } = await import("./agent-turn.js");
+    return await executeWorkbenchAgentTurn(executor ?? defaultWorkbenchAgentTurnExecutor, request);
+}
+async function writeAgentSubjectOutput(request, workload, subject, options = {}) {
+    if (request.operation !== "subject.run") {
+        throw new Error("Agent subject results can only complete subject.run operations.");
+    }
+    const traceRoot = path.join(request.paths.output, ".workbench", "internal", "agent-subject");
+    const agentResult = await executeBuiltInAgentTurn(options.agentExecutor, {
+        role: "runner",
+        provider: subject.agent,
+        adapterAuthRoot: options.adapterAuthRoot,
+        adapterAuthRequest: options.adapterAuthRequest,
+        adapterAuthEnv: options.adapterAuthEnv,
+        workspaceRoot: request.paths.workspace,
+        cwd: request.paths.cwd ?? request.paths.workspace,
+        prompt: buildAgentSubjectPrompt(workload, subject),
+        traceRoot,
+        jobId: workload.job.id,
+    });
+    const outputPath = path.join(request.paths.output, "subject-summary.md");
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, agentResult.output);
+    const trace = {
+        path: `.workbench/traces/${workload.job.id}/subject.json`,
+        kind: "text",
+        encoding: "utf8",
+        executable: false,
+        content: `${JSON.stringify({
+            kind: "agent_subject",
+            provider: subject.agent.use,
+            subjectId: workload.subjectId,
+            attemptIndex: workload.attemptIndex,
+            sampleIndex: workload.sampleIndex,
+            summary: agentResult.output,
+            metadata: agentResult.metadata,
+        }, null, 2)}\n`,
+    };
+    await writeSurfaceFiles(request.paths.output, [trace, ...agentResult.traceFiles]);
+    const runtime = await importWorkbenchRuntime();
+    const usage = runtime.assignUsageRole("runner", agentResult.usage);
+    await writeWorkbenchAdapterOperationResult(request.paths.output, {
+        protocol: "workbench.adapter-result.v1",
+        operation: "subject.run",
+        ok: true,
+        ...(agentResult.output ? { summary: agentResult.output } : {}),
+        feedback: {
+            subject: "agent",
+            agent: subject.agent.use,
+            metadata: agentResult.metadata,
+        },
+        ...(usage ? { usage } : {}),
+    });
+}
+function buildAgentSubjectPrompt(workload, subject) {
+    return [
+        ...(subject.instructions ? ["Instructions:", subject.instructions, ""] : []),
+        "Context:",
+        "- Subject files are mounted at /workspace/input/subject.",
+        "- Subject files are also present in the task working directory.",
+        ...(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.",
+        "- You may write inspection artifacts under /workspace/output.",
+    ].join("\n");
+}
+async function writeAgentSubjectRevisionOutput(request, workload, optimizer, options) {
+    if (request.operation !== "optimizer.improve") {
+        throw new Error("Agent subject revision results can only complete optimizer.improve operations.");
+    }
+    const traceRoot = path.join(request.paths.output, ".workbench", "internal", "agent-optimizer");
+    const agentResult = await executeBuiltInAgentTurn(options.agentExecutor, {
+        role: "optimizer",
+        provider: optimizer.agent,
+        adapterAuthRoot: options.adapterAuthRoot,
+        adapterAuthRequest: options.adapterAuthRequest,
+        adapterAuthEnv: options.adapterAuthEnv,
+        workspaceRoot: request.paths.workspace,
+        cwd: request.paths.cwd ?? request.paths.workspace,
+        prompt: buildAgentOptimizerPrompt(workload),
+        traceRoot,
+        jobId: workload.job.id,
+    });
+    const subjectPatch = await createSubjectPatchFromWorkspace({
+        beforeRoot: requiredRequestPath(request.paths.subject, "paths.subject"),
+        afterRoot: request.paths.cwd ?? request.paths.workspace,
+        edits: workload.optimizer.edits,
+    });
+    const changedSubjectPaths = subjectPatch.fileChanges.filter((filePath) => isSubjectEditPath(filePath, workload.optimizer.edits));
+    if (changedSubjectPaths.length === 0) {
+        throw new Error("Agent improve adapter completed without changing a subject file covered by optimizer edits.");
+    }
+    const trace = {
+        path: `.workbench/traces/${workload.job.id}/optimizer.json`,
+        kind: "text",
+        encoding: "utf8",
+        executable: false,
+        content: `${JSON.stringify({
+            kind: "agent_optimizer",
+            provider: optimizer.agent.use,
+            subjectId: workload.subjectId,
+            attemptIndex: workload.attemptIndex,
+            changedPaths: changedSubjectPaths,
+            summary: agentResult.output,
+            metadata: agentResult.metadata,
+        }, null, 2)}\n`,
+    };
+    await writeSurfaceFiles(request.paths.output, [trace, ...agentResult.traceFiles]);
+    const runtime = await importWorkbenchRuntime();
+    const usage = runtime.assignUsageRole("optimizer", agentResult.usage);
+    await writeWorkbenchAdapterOperationResult(request.paths.output, {
+        protocol: "workbench.adapter-result.v1",
+        operation: "optimizer.improve",
+        ok: true,
+        value: {
+            ...subjectPatch,
+            fileChanges: changedSubjectPaths,
+        },
+        ...(agentResult.output ? { summary: agentResult.output } : {}),
+        feedback: {
+            optimizer: optimizer.agent.use,
+            changedPaths: changedSubjectPaths,
+            metadata: agentResult.metadata,
+        },
+        ...(usage ? { usage } : {}),
+    });
+}
+function buildAgentOptimizerPrompt(workload) {
+    return [
+        "Benchmark:",
+        workload.benchmark.description || workload.benchmark.name,
+        "",
+        "Context:",
+        "- Subject files are mounted at /workspace/input/subject.",
+        "- Subject files are also present in the current working directory.",
+        "- Prior run traces are mounted at /workspace/input/traces.",
+        "- Use /workspace/input/traces as the source of truth for what happened in prior attempts.",
+        "- Do not mutate /workspace/input.",
+        "",
+        "Editable subject paths:",
+        workload.optimizer.edits.map((entry) => `- ${entry}`).join("\n"),
+        "",
+        "Output:",
+        "- Mutate the editable subject files directly in the current working directory.",
+        "- Include at least one changed subject file covered by the optimizer edits list.",
+    ].join("\n");
+}
+async function writeRubricJudgeResult(request, workload, engine, options = {}) {
+    const agentExecutor = options.agentExecutor;
+    const runtime = await importWorkbenchRuntime();
+    const criterionRuns = await mapWithConcurrency(engine.criteria, engine.parallelism, async (criterion) => runRubricCriterionJudge({
+        request,
+        workload,
+        engine,
+        criterion,
+        agentExecutor,
+        adapterAuthRoot: options.adapterAuthRoot,
+        adapterAuthRequest: options.adapterAuthRequest,
+        adapterAuthEnv: options.adapterAuthEnv,
+        runtime,
+    }));
+    const usage = runtime.mergeUsageSummaries(criterionRuns.map((run) => run.usage));
+    const result = rubricJudgeResultFromCriteria({
+        workload,
+        engine,
+        criterionRuns,
+    });
+    await writeWorkbenchAdapterOperationResult(request.paths.output, {
+        protocol: "workbench.adapter-result.v1",
+        operation: "engine.run",
+        ok: true,
+        value: result,
+        ...(typeof result.summary === "string" ? { summary: result.summary } : {}),
+        feedback: {
+            rubric: "criterion-fanout",
+            judge: engine.judge.use,
+            parallelism: engine.parallelism,
+            aggregation: "weighted_mean",
+            criteria: criterionRuns.map((run) => ({
+                id: run.result.criterion_id,
+                traceRoot: run.traceRoot,
+                metadata: run.metadata,
+                ...(run.repair ? { repair: run.repair } : {}),
+            })),
+        },
+        ...(usage ? { usage } : {}),
+    });
+}
+async function runRubricCriterionJudge(args) {
+    const traceRoot = path.join(args.request.paths.output, ".workbench", "internal", "rubric", safeInternalPathSegment(args.criterion.id));
+    const agentResult = await executeBuiltInAgentTurn(args.agentExecutor, {
+        role: "engine",
+        provider: args.engine.judge,
+        adapterAuthRoot: args.adapterAuthRoot,
+        adapterAuthRequest: args.adapterAuthRequest,
+        adapterAuthEnv: args.adapterAuthEnv,
+        workspaceRoot: args.request.paths.workspace,
+        cwd: args.request.paths.cwd ?? args.request.paths.workspace,
+        prompt: buildRubricCriterionJudgePrompt(args.workload, args.engine, args.criterion),
+        traceRoot: path.join(traceRoot, "judge"),
+        jobId: args.workload.job.id,
+    });
+    let usage = args.runtime.assignUsageRole("engine", agentResult.usage);
+    try {
+        return {
+            ...normalizeRubricCriterionJudgeResult(agentResult.output, args.criterion),
+            metadata: agentResult.metadata,
+            traceRoot,
+            ...(usage ? { usage } : {}),
+        };
+    }
+    catch (error) {
+        const repairError = error instanceof Error ? error.message : String(error);
+        const repairResult = await executeBuiltInAgentTurn(args.agentExecutor, {
+            role: "engine",
+            provider: args.engine.judge,
+            adapterAuthRoot: args.adapterAuthRoot,
+            adapterAuthRequest: args.adapterAuthRequest,
+            adapterAuthEnv: args.adapterAuthEnv,
+            workspaceRoot: args.request.paths.workspace,
+            cwd: args.request.paths.cwd ?? args.request.paths.workspace,
+            prompt: buildRubricCriterionRepairPrompt({
+                output: agentResult.output,
+                error: repairError,
+                criterion: args.criterion,
+            }),
+            traceRoot: path.join(traceRoot, "repair"),
+            jobId: args.workload.job.id,
+        });
+        usage = args.runtime.mergeUsageSummaries([
+            usage,
+            args.runtime.assignUsageRole("engine", repairResult.usage),
+        ]);
+        return {
+            ...normalizeRubricCriterionJudgeResult(repairResult.output, args.criterion),
+            metadata: {
+                ...repairResult.metadata,
+                repair: {
+                    attempted: true,
+                    originalError: repairError,
+                    originalMetadata: agentResult.metadata,
+                },
+            },
+            traceRoot,
+            repair: {
+                attempted: true,
+                originalError: repairError,
+            },
+            ...(usage ? { usage } : {}),
+        };
+    }
+}
+function buildRubricCriterionJudgePrompt(workload, engine, criterion) {
+    requireWorkloadTask(workload, "Rubric judge");
+    return [
+        ...(engine.instructions ? ["Instructions:", engine.instructions, ""] : []),
+        ...(workload.case?.prompt ? ["Case:", workload.case.prompt, ""] : []),
+        "Criterion:",
+        JSON.stringify(criterion, null, 2),
+        "",
+        "Context:",
+        "- The subject already ran in this same working directory.",
+        "- Subject 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.",
+        "- Score only from the current working directory, public case files, verifier-private files, and the criterion above.",
+        "",
+        "Output:",
+        "Return only a JSON object. Do not wrap it in Markdown.",
+        "The JSON object must score exactly this one criterion. Use this shape:",
+        JSON.stringify({
+            criterion_id: criterion.id,
+            score: 0.0,
+            pass: false,
+            rationale: "why this criterion received this score",
+            summary: "short grading summary",
+            feedback: {},
+        }, null, 2),
+        `The only allowed criterion_id is ${criterion.id}.`,
+        "The rationale must be non-empty and specific to this criterion.",
+    ].join("\n");
+}
+function buildRubricCriterionRepairPrompt(input) {
+    return [
+        "The previous Workbench rubric criterion judge response was rejected by the result parser.",
+        "",
+        `Parser error: ${input.error}`,
+        "",
+        "Convert the previous response into one valid JSON object. Return only JSON, with no Markdown.",
+        "Preserve the prior score, rationale, and feedback whenever they are present.",
+        "If the previous response uses clear qualitative scoring, convert only these terms: perfect/full pass/pass = 1, fail/no credit = 0, partial = 0.5.",
+        "If the required score is still not recoverable from the previous response, use score 0, pass false, and rationale \"The judge response did not provide a recoverable score and rationale for this criterion.\"",
+        "Do not invent file paths, log paths, or extra criterion ids.",
+        "",
+        "Criterion:",
+        JSON.stringify(input.criterion, null, 2),
+        "",
+        "Required JSON shape:",
+        JSON.stringify({
+            criterion_id: input.criterion.id,
+            score: 0.0,
+            pass: false,
+            rationale: "why this criterion received this score",
+            summary: "short grading summary",
+            feedback: {},
+        }, null, 2),
+        "",
+        `The only allowed criterion_id is ${input.criterion.id}.`,
+        "",
+        "Previous response:",
+        input.output,
+    ].join("\n");
+}
+function rubricJudgeResultFromCriteria(args) {
+    const criteria = args.criterionRuns.map((run) => run.result);
+    const score = weightedCriteriaScore(criteria, args.engine.criteria);
+    if (!isBoundedScore(score)) {
+        throw new Error("Rubric criterion scores must aggregate to a score in the 0..1 range.");
+    }
+    const metrics = { score };
+    for (const criterion of criteria) {
+        metrics[`criterion__${criterion.criterion_id}`] = criterion.score;
+    }
+    const caseResult = rubricJudgeCaseResult({
+        workload: args.workload,
+        score,
+        criteria,
+    });
+    const passed = criteria.filter((criterion) => criterion.pass).length;
+    return {
+        score,
+        metrics,
+        summary: `Rubric judged ${criteria.length} criteria (${passed} passed).`,
+        cases: [caseResult],
+        feedback: {
+            judge: args.engine.judge.use,
+            rubric: {
+                parallelism: args.engine.parallelism,
+                aggregation: "weighted_mean",
+                criteria: args.criterionRuns.map((run) => ({
+                    id: run.result.criterion_id,
+                    score: run.result.score,
+                    pass: run.result.pass,
+                    ...(run.summary ? { summary: run.summary } : {}),
+                    ...(run.feedback !== undefined ? { feedback: run.feedback } : {}),
+                    metadata: run.metadata,
+                    ...(run.repair ? { repair: run.repair } : {}),
+                })),
+            },
+        },
+    };
+}
+function normalizeRubricCriterionJudgeResult(output, criterion) {
+    const parsed = parseAgentJsonObject(output, "Rubric judge");
+    const result = normalizeRubricCriterionObject(parsed, criterion);
+    const score = result.score;
+    if (!isBoundedScore(score)) {
+        throw new Error("Rubric criterion judge output must include a score in the 0..1 range.");
+    }
+    return {
+        result,
+        ...(typeof parsed.summary === "string" ? { summary: parsed.summary } : {}),
+        ...(parsed.feedback !== undefined ? { feedback: parsed.feedback } : {}),
+    };
+}
+function rubricJudgeCaseResult(args) {
+    return {
+        id: args.workload.caseId,
+        status: "completed",
+        metrics: { score: args.score },
+        criteria: args.criteria,
+    };
+}
+function readCriterionRationale(record) {
+    for (const key of ["rationale", "feedback", "reason", "explanation"]) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function normalizeRubricCriterionObject(record, criterion) {
+    const criterionId = typeof record.criterion_id === "string"
+        ? record.criterion_id
+        : "";
+    if (criterionId !== criterion.id) {
+        throw new Error(`Rubric criterion judge output must use criterion_id ${criterion.id}.`);
+    }
+    if (!isBoundedScore(record.score)) {
+        throw new Error(`Rubric criterion ${criterion.id} output must include a score in the 0..1 range.`);
+    }
+    const rationale = readCriterionRationale(record);
+    if (!rationale) {
+        throw new Error(`Rubric criterion ${criterion.id} output must include a non-empty rationale.`);
+    }
+    return {
+        criterion_id: criterion.id,
+        label: typeof record.label === "string" && record.label.length > 0 ? record.label : criterion.id,
+        score: record.score,
+        pass: typeof record.pass === "boolean" ? record.pass : record.score >= 0.5,
+        rationale,
+    };
+}
+function rubricCriteria(value, label) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${label} must be an array.`);
+    }
+    const seen = new Set();
+    return value.map((entry, index) => {
+        const record = jsonRecord(entry);
+        const id = record.id;
+        const description = record.description;
+        if (typeof id !== "string" || id.length === 0) {
+            throw new Error(`Spec must include ${label}[${index}].id.`);
+        }
+        if (seen.has(id)) {
+            throw new Error(`${label}[${index}].id duplicates another rubric criterion id.`);
+        }
+        seen.add(id);
+        if (typeof description !== "string" || description.length === 0) {
+            throw new Error(`Spec must include ${label}[${index}].description.`);
+        }
+        return {
+            id,
+            description,
+            ...(typeof record.weight === "number" ? { weight: record.weight } : {}),
+        };
+    });
+}
+function rubricParallelism(value, criterionCount) {
+    if (criterionCount <= 0) {
+        return 1;
+    }
+    if (value === undefined) {
+        return Math.min(DEFAULT_RUBRIC_PARALLELISM, criterionCount);
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error("adapter.with.parallelism must be a positive integer.");
+    }
+    return Math.min(value, criterionCount);
+}
+async function mapWithConcurrency(inputs, concurrency, mapper) {
+    const limit = Math.max(1, Math.min(concurrency, inputs.length || 1));
+    const results = new Array(inputs.length);
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < inputs.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            results[index] = await mapper(inputs[index], index);
+        }
+    }
+    await Promise.all(Array.from({ length: limit }, async () => worker()));
+    return results;
+}
+function requireWorkloadTask(workload, label) {
+    if (!workload.case) {
+        throw new Error(`${label} workload is missing case text.`);
+    }
+}
+async function createSubjectPatchFromWorkspace(args) {
+    const before = new Map((await readSurfaceFilesRecursive(args.beforeRoot))
+        .map((file) => [normalizeRelativePath(file.path), file]));
+    const changedFiles = (await readSurfaceFilesRecursive(args.afterRoot))
+        .map((file) => ({ ...file, path: normalizeRelativePath(file.path) }))
+        .filter((file) => isSubjectEditPath(file.path, args.edits) &&
+        !isRuntimeWorkspacePath(file.path) &&
+        !sameSurfaceFile(before.get(file.path), file))
+        .sort((left, right) => left.path.localeCompare(right.path));
+    return {
+        files: changedFiles,
+        fileChanges: changedFiles.map((file) => file.path),
+    };
+}
+function sameSurfaceFile(left, right) {
+    return !!left &&
+        left.kind === right.kind &&
+        left.encoding === right.encoding &&
+        left.content === right.content &&
+        left.executable === right.executable;
+}
+function isRuntimeWorkspacePath(filePath) {
+    const normalized = normalizeRelativePath(filePath);
+    return normalized === ".workbench" ||
+        normalized.startsWith(".workbench/") ||
+        normalized === "input" ||
+        normalized.startsWith("input/") ||
+        normalized === "output" ||
+        normalized.startsWith("output/") ||
+        normalized === "logs" ||
+        normalized.startsWith("logs/") ||
+        normalized === "private" ||
+        normalized.startsWith("private/");
+}
+async function writeSurfaceFiles(root, files) {
+    for (const file of files) {
+        const target = path.join(root, normalizeRelativePath(file.path));
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        const body = file.encoding === "base64"
+            ? Buffer.from(file.content, "base64")
+            : Buffer.from(file.content, "utf8");
+        await fs.writeFile(target, body);
+        if (file.executable) {
+            await fs.chmod(target, 0o755).catch(() => undefined);
+        }
+    }
+}
+function isSubjectEditPath(filePath, edits) {
+    const normalized = normalizeRelativePath(filePath);
+    return edits.some((entry) => {
+        const editPath = normalizeRelativePath(entry).replace(/\/+$/u, "");
+        return normalized === editPath || normalized.startsWith(`${editPath}/`);
+    });
+}
+function normalizeRelativePath(filePath) {
+    const normalized = filePath.replace(/\\/gu, "/").replace(/^\/+/u, "");
+    return normalized.split("/").filter(Boolean).join("/");
+}
+function parseAgentJsonObject(output, label) {
+    const trimmed = output.trim();
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start < 0 || end < start) {
+        throw new Error(`${label} output must be a JSON object.`);
+    }
+    let parsed;
+    const jsonText = trimmed.slice(start, end + 1);
+    try {
+        parsed = parseAgentJsonText(jsonText);
+    }
+    catch (error) {
+        throw new Error(`${label} output must parse as a JSON object: ${error instanceof Error ? error.message : String(error)}.`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${label} output must be a JSON object.`);
+    }
+    return parsed;
+}
+function parseAgentJsonText(jsonText) {
+    try {
+        return JSON.parse(jsonText);
+    }
+    catch (error) {
+        const repaired = repairInvalidJsonStringEscapes(jsonText);
+        if (repaired !== jsonText) {
+            try {
+                return JSON.parse(repaired);
+            }
+            catch {
+                // Preserve the original parse error; it points at the model output.
+            }
+        }
+        throw error;
+    }
+}
+function repairInvalidJsonStringEscapes(jsonText) {
+    let repaired = "";
+    let inString = false;
+    let escaped = false;
+    for (const char of jsonText) {
+        if (!inString) {
+            repaired += char;
+            if (char === "\"") {
+                inString = true;
+            }
+            continue;
+        }
+        if (escaped) {
+            repaired += isJsonEscapeCharacter(char) ? char : `\\${char}`;
+            escaped = false;
+            continue;
+        }
+        repaired += char;
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (char === "\"") {
+            inString = false;
+        }
+    }
+    if (escaped) {
+        repaired += "\\";
+    }
+    return repaired;
+}
+function isJsonEscapeCharacter(char) {
+    return char === "\""
+        || char === "\\"
+        || char === "/"
+        || char === "b"
+        || char === "f"
+        || char === "n"
+        || char === "r"
+        || char === "t"
+        || char === "u";
+}
+function isBoundedScore(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function weightedCriteriaScore(criteria, specCriteria) {
+    if (criteria.length === 0) {
+        return undefined;
+    }
+    const weights = new Map(specCriteria.map((criterion) => [criterion.id, criterion.weight ?? 1]));
+    let numerator = 0;
+    let denominator = 0;
+    for (const criterion of criteria) {
+        const weight = weights.get(criterion.criterion_id) ?? 1;
+        numerator += criterion.score * weight;
+        denominator += weight;
+    }
+    return denominator > 0 ? Number((numerator / denominator).toFixed(6)) : undefined;
+}
+function jsonRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function isJsonPayload(value) {
+    return value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        (Array.isArray(value) && value.every(isJsonPayload)) ||
+        (typeof value === "object" && value !== null && Object.values(value).every(isJsonPayload));
+}