@dailephd/my-dev-kit-lab 0.9.1 → 0.9.3

package/dist/src/core/runMeasuredCommand.js

@@ -49,6 +49,7 @@ export async function runMeasuredCommand(options) {
         let timedOut = false;
         let timeout;
         let killGraceTimeout;
+        let terminationPromise;
         let settled = false;
         let child;
         try {
@@ -99,7 +100,7 @@ export async function runMeasuredCommand(options) {
         const KILL_GRACE_MS = 3000;
         const terminate = () => {
             if (options.terminateProcessTree === true) {
-                void terminateProcessTree(child.pid);
+                terminationPromise ??= terminateProcessTree(child.pid);
             }
             else {
                 forceTerminateProcess(child.pid);
@@ -145,14 +146,19 @@ export async function runMeasuredCommand(options) {
             child.stdin?.write(options.stdinText, "utf8");
             child.stdin?.end();
         }
-        // forceTerminateProcess is fire-and-forget (it never confirms the target process tree actually
-        // exited: on Windows it spawns a detached `taskkill /T /F` and does not await or check its
-        // result). That is normally sufficient, but a grandchild process spawned through an
-        // intermediate shim (for example a Windows .cmd launcher) can occasionally outlive an
-        // already-killed intermediate process. Without a bounded fallback, a caller whose kill silently
-        // failed would await this promise forever instead of receiving the already-known timeout error.
-        // (KILL_GRACE_MS and the shared `terminate` step are declared above, beside the output collectors.)
+        // Tree termination is awaited before a bounded result is returned. The helper has its own
+        // platform-specific time bound; a failed or timed-out tree kill remains visible in `error`.
+        // Non-tree callers retain the legacy kill-grace fallback below.
         const settle = async (exitCode) => {
+            if (settled)
+                return;
+            if (terminationPromise) {
+                const terminated = await terminationPromise;
+                if (!terminated) {
+                    const cleanupError = "Could not confirm termination of the command process tree.";
+                    spawnError = spawnError ? `${spawnError} ${cleanupError}` : cleanupError;
+                }
+            }
             if (settled)
                 return;
             settled = true;

package/dist/src/experiments/plugins/agentSuccessRate/campaignCheckpointStore.js

@@ -4,7 +4,8 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveWithinRoot } from "../../../core/pathSafety.js";
 import { isSameOrInside, resolvePhysicalPath } from "../../../evaluation/benchmarkSandbox/pathPolicy.js";
-import { campaignAssert, campaignHash, canonicalCampaignJson, compareCampaignIdentity, validateCampaignIdentity } from "./campaignIdentity.js";
+import { CAMPAIGN_IDENTITY_VERSION_V2, campaignAssert, campaignHash, canonicalCampaignJson, compareCampaignIdentity, validateCampaignIdentity } from "./campaignIdentity.js";
+import { PROMPT_CONTRACT_ARTIFACT_FILE, renderPromptContractArtifact } from "./promptContract.js";
 import { CAMPAIGN_CHECKPOINT_MAX_BYTES, requiredCampaignArtifacts, validateCampaignCheckpoint, validateCampaignCompletion, validateCampaignHistory, validateCampaignRelativePath } from "./campaignCheckpoint.js";
 import { projectCampaignTreatmentEvidence } from "./campaignCheckpoint.js";
 import { analyzeAgentSuccessTreatment } from "./analysis.js";
@@ -46,7 +47,7 @@ async function plainAncestors(candidate) {
     }
 }
 /** Resolve filesystem aliases before inspecting ancestors (macOS exposes /var as /private/var). */
-async function resolveCampaignRoot(candidate) {
+export async function resolveCampaignRoot(candidate) {
     const resolved = path.resolve(candidate);
     let existing = resolved;
     const remainder = [];
@@ -160,8 +161,29 @@ export async function prepareCampaignCompletion(boundary, identity, task, source
     validateCampaignCompletion(result, identity, task, source.treatmentId);
     return result;
 }
+/**
+ * A V2 identity binds the effective prompt contract. Every attempt directory that holds provider artifacts must also hold
+ * prompt-contract.json whose bytes equal the deterministic rendering of the identity's contract. The expectation comes from
+ * the checksummed identity, so the sidecar cannot vouch for itself and the closed V1 checkpoint schema is not extended.
+ */
+async function verifyPromptContractArtifacts(root, identity, references) {
+    if (identity.schemaVersion !== CAMPAIGN_IDENTITY_VERSION_V2)
+        return;
+    const expected = Buffer.from(renderPromptContractArtifact(identity.promptContract), "utf8");
+    const directories = new Set(references.filter((r) => r.kind === "provider").map((r) => path.posix.dirname(r.path)));
+    for (const directoryPath of [...directories].sort()) {
+        const bytes = await boundedRead(await safeFile(root, `${directoryPath}/${PROMPT_CONTRACT_ARTIFACT_FILE}`), 1024 * 1024);
+        campaignAssert(bytes.equals(expected), "PROMPT_CONTRACT_ARTIFACT");
+    }
+}
 async function verifyArtifacts(boundary, checkpoint) {
     const root = await validateRoot(boundary);
+    for (const unit of checkpoint.units)
+        await verifyPromptContractArtifacts(root, checkpoint.identity, unit.completion?.artifacts ?? []);
+    if (checkpoint.schemaVersion === CAMPAIGN_CHECKPOINT_SCHEMA_V2)
+        for (const unit of checkpoint.units)
+            for (const epoch of unit.epochs)
+                await verifyPromptContractArtifacts(root, checkpoint.identity, epoch.terminal?.artifacts ?? []);
     for (const unit of checkpoint.units)
         for (const reference of unit.completion?.artifacts ?? []) {
             const bytes = await boundedRead(await safeFile(root, reference.path), 32 * 1024 * 1024);

package/dist/src/experiments/plugins/agentSuccessRate/campaignExecution.js

@@ -20,6 +20,7 @@ import { buildAgentSuccessRateExecutionArtifact, validateAgentSuccessRateExecuti
 import { buildAgentSuccessRateAnalysisArtifact, validateAgentSuccessRateAnalysisArtifact, validateAgentSuccessRateArtifactFamily, AGENT_SUCCESS_RATE_ANALYSIS_ARTIFACT_FILE } from "./analysisArtifact.js";
 import { defaultContextDependencies, sealTask, writeAgentSuccessRateArtifactTargets } from "./plugin.js";
 import { DEFAULT_AGENT_SUCCESS_KIT_COMMAND } from "./contextGeneration.js";
+import { promptContractMatchesCurrentRenderer } from "./promptContract.js";
 import { executeResumableCampaign } from "./campaignResumableExecution.js";
 const preparations = new WeakMap();
 async function establishPhysicalRoot(root) {
@@ -81,7 +82,7 @@ async function produceIdentity(input) {
         projects.push({ projectId, files });
     }
     const provider = input.provider;
-    const allowed = provider.kind === "deterministic-fixture" ? ["kind"] : provider.kind === "trusted-simulated-provider" ? ["kind", "simulationId", "providerId", "timeoutMs", "repairAttempts", "runAgent", "contextDependencies"] : ["kind", "providerId", "timeoutMs", "repairAttempts", "includeRealAgents", "trustedExecutable", "kitCommand", "contextDependencies", "env"];
+    const allowed = provider.kind === "deterministic-fixture" ? ["kind"] : provider.kind === "trusted-simulated-provider" ? ["kind", "simulationId", "providerId", "timeoutMs", "repairAttempts", "runAgent", "contextDependencies", "promptContract"] : ["kind", "providerId", "timeoutMs", "repairAttempts", "includeRealAgents", "trustedExecutable", "kitCommand", "contextDependencies", "env", "promptContract"];
     campaignAssert(Object.keys(provider).every(key => allowed.includes(key)), "INCONSISTENT_EXECUTION_MODE");
     const simulated = provider.kind === "trusted-simulated-provider";
     campaignAssert(["deterministic-fixture", "trusted-simulated-provider", "real-agent"].includes(provider.kind), "INVALID_EXECUTION_MODE");
@@ -102,6 +103,9 @@ async function produceIdentity(input) {
             await rm(commandsDir, { recursive: true, force: true });
         }
     }
+    const promptContract = provider.kind === "deterministic-fixture" ? null : provider.promptContract ?? null;
+    if (promptContract !== null && provider.kind !== "deterministic-fixture")
+        campaignAssert(promptContract.providerId === provider.providerId && promptContractMatchesCurrentRenderer(promptContract), "PROMPT_CONTRACT_UNVERIFIABLE");
     const functions = (object) => Object.entries(object).map(([key, value]) => ({ key, source: String(value) })).sort((a, b) => a.key < b.key ? -1 : 1);
     return createCampaignIdentity({
         tasks: input.tasks,
@@ -109,6 +113,7 @@ async function produceIdentity(input) {
         config: provider.kind === "deterministic-fixture" ? { providerId: provider.kind, timeoutMs: 1000, repairAttempts: 0 } : { providerId: provider.providerId, timeoutMs: provider.timeoutMs, repairAttempts: provider.repairAttempts },
         contextConfiguration: { contract: "existing-agent-success-context-v1", treatments: [...input.treatments] },
         retrievalConfiguration: { contract: simulated ? "trusted-simulated-retrieval-v1" : real ? "real-provider-retrieval-v1" : "no-retrieval-fixture-v1", dependencies: simulated ? functions(provider.contextDependencies) : real ? functions(provider.contextDependencies ?? defaultContextDependencies()) : [], ...(real ? { kitCommand: provider.kitCommand ?? DEFAULT_AGENT_SUCCESS_KIT_COMMAND, version: retrievalVersion } : {}), executionDependencies: functions(input.dependencies ?? {}) },
+        promptContract,
         verifiedProviderObservation: simulated ? Buffer.from(canonicalCampaignJson({ contract: "trusted-simulated-provider-v1", simulationId: provider.simulationId, implementation: String(provider.runAgent) })) : observed
     });
 }
@@ -206,7 +211,7 @@ export async function executeAgentSuccessCampaign(prepared, args) {
                 const result = provider.kind === "trusted-simulated-provider" && contexts ? await executeAgentSuccessRepairTreatment({ ...common, repair: {
                         providerId: provider.providerId, repairAttempts: provider.repairAttempts,
                         createProposalSource: ({ attemptNumber, feedback }) => createRealAgentProposalSource({
-                            settings: { providerId: provider.providerId, timeoutMs: provider.timeoutMs, outDir: boundary.outputRoot, privateRoots: common.privateRoots, protectedRoots: [boundary.toolRoot, boundary.outputRoot, runtimeRoot, canonicalProjectRoot],
+                            settings: { providerId: provider.providerId, timeoutMs: provider.timeoutMs, ...(provider.promptContract ? { promptContract: provider.promptContract } : {}), outDir: boundary.outputRoot, privateRoots: common.privateRoots, protectedRoots: [boundary.toolRoot, boundary.outputRoot, runtimeRoot, canonicalProjectRoot],
                                 runAgent: async (request) => {
                                     await assertCampaignDispatch(boundary, identity, ownership);
                                     await prepareCampaignProviderOutput(boundary, identity, ownership, agentSuccessAgentArtifactDirectory(task.benchmarkProject, task.id, unit.treatmentId, attemptNumber));

package/dist/src/experiments/plugins/agentSuccessRate/campaignIdentity.js

@@ -1,11 +1,14 @@
 import { createHash } from "node:crypto";
 import { validateAgentSuccessTask } from "../../../evaluation/agentSuccess/index.js";
 import { AGENT_SUCCESS_RATE_TREATMENT_IDS } from "./metadata.js";
+import { assertPromptContractShape, promptContractDigest } from "./promptContract.js";
 export const CAMPAIGN_IDENTITY_VERSION = "my-dev-kit-lab-agent-success-rate-campaign-identity-v1";
+/** V2 extends V1 with the normalized prompt contract and its digest; V1 evidence stays readable and unchanged. */
+export const CAMPAIGN_IDENTITY_VERSION_V2 = "my-dev-kit-lab-agent-success-rate-campaign-identity-v2";
 export const CAMPAIGN_COMPONENTS = ["corpus", "tasks", "projects", "checks", "behavior", "context", "retrieval", "execution", "providerBuild"];
 export const CAMPAIGN_SOURCE_FILES = ["src/agents/types.ts", "src/agents/normalizeAgentTelemetry.ts", "src/agents/parseAgentTokenUsage.ts", "src/agents/runAgentPrompt.ts", "src/agents/adapters/codexAdapter.ts", "src/agents/adapters/claudeAdapter.ts", "src/evaluation/classifyAgentRunOutcome.ts", "src/experiments/plugins/agentSuccessRate/execution.ts", "src/experiments/plugins/agentSuccessRate/realAgentExecution.ts", "src/experiments/plugins/agentSuccessRate/contextGeneration.ts", "src/experiments/plugins/agentSuccessRate/repairExecution.ts", "src/experiments/plugins/agentSuccessRate/repairPolicy.ts", "src/experiments/plugins/agentSuccessRate/analysis.ts", "src/experiments/plugins/agentSuccessRate/plugin.ts"];
 /** Additional transitive execution/safety owners; a missing source contract cannot certify reuse. */
-export const CAMPAIGN_DEPENDENCY_FILES = ["src/experiments/plugins/agentSuccessRate/executionTypes.ts", "src/experiments/plugins/agentSuccessRate/analysisTypes.ts", "src/experiments/plugins/agentSuccessRate/attemptEvidence.ts", "src/experiments/plugins/agentSuccessRate/campaignIdentity.ts", "src/experiments/plugins/agentSuccessRate/campaignCheckpoint.ts", "src/experiments/plugins/agentSuccessRate/campaignCheckpointStore.ts", "src/evaluation/agentSuccess/patchTypes.ts", "src/evaluation/agentSuccess/taskTypes.ts", "src/evaluation/agentSuccess/verificationTypes.ts", "src/evaluation/agentSuccess/corpusTypes.ts", "src/evaluation/benchmarkSandbox/types.ts", "src/evaluation/benchmarkSandbox/errors.ts", "src/evaluation/changeSet/types.ts", "src/agents/agentRegistry.ts", "src/core/pathSafety.ts", "src/core/runMeasuredCommand.ts", "src/core/resolveCommand.ts", "src/core/processTree.ts", "src/core/fileGlobs.ts", "src/core/countTokens.ts", "src/core/commandLine.ts", "src/runtime/managedProcess.ts", "src/evaluation/runMyDevKitRetrieval.ts", "src/evaluation/agentSuccess/assessBaseline.ts", "src/evaluation/agentSuccess/applyPatchToSandbox.ts", "src/evaluation/agentSuccess/extractPatchCandidate.ts", "src/evaluation/agentSuccess/parseUnifiedDiff.ts", "src/evaluation/agentSuccess/runVerificationCheck.ts", "src/evaluation/agentSuccess/taskPaths.ts", "src/evaluation/agentSuccess/validatePatchPolicy.ts", "src/evaluation/agentSuccess/validateAgentSuccessTask.ts", "src/evaluation/agentSuccess/readAgentSuccessCorpus.ts", "src/evaluation/agentSuccess/validateAgentSuccessCorpus.ts", "src/evaluation/benchmarkSandbox/createBenchmarkSandbox.ts", "src/evaluation/benchmarkSandbox/removeBenchmarkSandbox.ts", "src/evaluation/benchmarkSandbox/pathPolicy.ts", "src/evaluation/benchmarkSandbox/treeSnapshot.ts", "src/evaluation/benchmarkSandbox/gitExecutor.ts", "src/evaluation/benchmarkSandbox/minimalHostEnv.ts", "src/evaluation/changeSet/captureChangeSet.ts", "src/experiments/plugins/agentSuccessRate/agentTaskProjection.ts", "src/experiments/plugins/agentSuccessRate/realAgentPrompt.ts", "src/experiments/plugins/agentSuccessRate/repairFeedback.ts", "src/experiments/plugins/agentSuccessRate/repairAnalysis.ts", "src/experiments/plugins/agentSuccessRate/metadata.ts", "src/experiments/plugins/agentSuccessRate/config.ts", "src/experiments/plugins/agentSuccessRate/executionArtifact.ts", "src/experiments/plugins/agentSuccessRate/analysisArtifact.ts", "src/experiments/outputPaths.ts"];
+export const CAMPAIGN_DEPENDENCY_FILES = ["src/experiments/plugins/agentSuccessRate/executionTypes.ts", "src/experiments/plugins/agentSuccessRate/analysisTypes.ts", "src/experiments/plugins/agentSuccessRate/attemptEvidence.ts", "src/experiments/plugins/agentSuccessRate/campaignIdentity.ts", "src/experiments/plugins/agentSuccessRate/campaignCheckpoint.ts", "src/experiments/plugins/agentSuccessRate/campaignCheckpointStore.ts", "src/evaluation/agentSuccess/patchTypes.ts", "src/evaluation/agentSuccess/taskTypes.ts", "src/evaluation/agentSuccess/verificationTypes.ts", "src/evaluation/agentSuccess/corpusTypes.ts", "src/evaluation/benchmarkSandbox/types.ts", "src/evaluation/benchmarkSandbox/errors.ts", "src/evaluation/changeSet/types.ts", "src/agents/agentRegistry.ts", "src/core/pathSafety.ts", "src/core/runMeasuredCommand.ts", "src/core/resolveCommand.ts", "src/core/processTree.ts", "src/core/fileGlobs.ts", "src/core/countTokens.ts", "src/core/commandLine.ts", "src/runtime/managedProcess.ts", "src/evaluation/runMyDevKitRetrieval.ts", "src/evaluation/agentSuccess/assessBaseline.ts", "src/evaluation/agentSuccess/applyPatchToSandbox.ts", "src/evaluation/agentSuccess/extractPatchCandidate.ts", "src/evaluation/agentSuccess/parseUnifiedDiff.ts", "src/evaluation/agentSuccess/runVerificationCheck.ts", "src/evaluation/agentSuccess/taskPaths.ts", "src/evaluation/agentSuccess/validatePatchPolicy.ts", "src/evaluation/agentSuccess/validateAgentSuccessTask.ts", "src/evaluation/agentSuccess/readAgentSuccessCorpus.ts", "src/evaluation/agentSuccess/validateAgentSuccessCorpus.ts", "src/evaluation/benchmarkSandbox/createBenchmarkSandbox.ts", "src/evaluation/benchmarkSandbox/removeBenchmarkSandbox.ts", "src/evaluation/benchmarkSandbox/pathPolicy.ts", "src/evaluation/benchmarkSandbox/treeSnapshot.ts", "src/evaluation/benchmarkSandbox/gitExecutor.ts", "src/evaluation/benchmarkSandbox/minimalHostEnv.ts", "src/evaluation/changeSet/captureChangeSet.ts", "src/experiments/plugins/agentSuccessRate/agentTaskProjection.ts", "src/experiments/plugins/agentSuccessRate/realAgentPrompt.ts", "src/experiments/plugins/agentSuccessRate/promptContract.ts", "src/experiments/plugins/agentSuccessRate/strictDiffResponse.ts", "src/experiments/plugins/agentSuccessRate/repairFeedback.ts", "src/experiments/plugins/agentSuccessRate/repairAnalysis.ts", "src/experiments/plugins/agentSuccessRate/metadata.ts", "src/experiments/plugins/agentSuccessRate/config.ts", "src/experiments/plugins/agentSuccessRate/executionArtifact.ts", "src/experiments/plugins/agentSuccessRate/analysisArtifact.ts", "src/experiments/outputPaths.ts"];
 export function campaignAssert(condition, code = "INVALID_CHECKPOINT") {
     if (!condition)
         throw new Error(code);
@@ -42,8 +45,10 @@ export function campaignExact(value, keys) {
     campaignAssert(Object.keys(value).sort().join("\0") === [...keys].sort().join("\0"));
 }
 export function validateCampaignIdentity(value) {
-    campaignExact(value, ["schemaVersion", "algorithm", "pluginContract", "digest", "selected", "treatmentOrder", "config", "components"]);
-    campaignAssert(value.schemaVersion === CAMPAIGN_IDENTITY_VERSION && value.algorithm === "sha256" && value.pluginContract === "agent-success-rate/1.0.0", "INCOMPATIBLE_IDENTITY");
+    const v2 = typeof value === "object" && value !== null && value.schemaVersion === CAMPAIGN_IDENTITY_VERSION_V2;
+    const baseKeys = ["schemaVersion", "algorithm", "pluginContract", "digest", "selected", "treatmentOrder", "config", "components"];
+    campaignExact(value, v2 ? [...baseKeys, "promptContract", "promptContractDigest"] : baseKeys);
+    campaignAssert(value.schemaVersion === (v2 ? CAMPAIGN_IDENTITY_VERSION_V2 : CAMPAIGN_IDENTITY_VERSION) && value.algorithm === "sha256" && value.pluginContract === "agent-success-rate/1.0.0", "INCOMPATIBLE_IDENTITY");
     campaignAssert(Array.isArray(value.selected) && value.selected.length > 0 && value.selected.length <= 1000);
     const ids = new Set();
     for (const row of value.selected) {
@@ -60,6 +65,17 @@ export function validateCampaignIdentity(value) {
         campaignExact(component, ["version", "digest"]);
         campaignAssert(component.version === "1" && (component.digest === null || isCampaignDigest(component.digest)));
     }
+    if (v2) {
+        try {
+            assertPromptContractShape(value.promptContract);
+        }
+        catch {
+            campaignAssert(false, "PROMPT_CONTRACT_INVALID");
+        }
+        const contract = value.promptContract;
+        campaignAssert(contract.providerId === value.config.providerId, "PROMPT_CONTRACT_PROVIDER_MISMATCH");
+        campaignAssert(isCampaignDigest(value.promptContractDigest) && value.promptContractDigest === promptContractDigest(contract), "PROMPT_CONTRACT_DIGEST");
+    }
     const { digest, ...body } = value;
     campaignAssert(isCampaignDigest(digest) && digest === campaignHash(canonicalCampaignJson(body)), "IDENTITY_INTEGRITY");
 }
@@ -83,7 +99,12 @@ export function createCampaignIdentity(input) {
         projects = digest(input.projects.map((p) => ({ projectId: p.projectId, files: manifest(p.files) })).sort((a, b) => a.projectId < b.projectId ? -1 : a.projectId > b.projectId ? 1 : 0));
     }
     const values = { corpus: input.corpusBytes === null ? null : campaignHash(input.corpusBytes), tasks: digest(input.tasks), projects, checks: digest(input.tasks.map((t) => ({ id: t.id, task: t.taskChecks, regression: t.regressionChecks, protected: t.protectedFiles }))), behavior: digest(input.tasks.map((t) => ({ id: t.id, facts: t.behaviorFacts, expected: t.expectedEditFiles, allowed: t.allowedEditFiles }))), context: input.contextConfiguration === null ? null : digest(input.contextConfiguration), retrieval: input.retrievalConfiguration === null ? null : digest(input.retrievalConfiguration), execution: source, providerBuild: input.config.providerId === "deterministic-fixture" ? digest("no-provider-invocation-v1") : input.verifiedProviderObservation === null ? null : campaignHash(input.verifiedProviderObservation) };
-    const body = { schemaVersion: CAMPAIGN_IDENTITY_VERSION, algorithm: "sha256", pluginContract: "agent-success-rate/1.0.0", selected: input.tasks.map((t) => ({ caseId: t.id, projectId: t.benchmarkProject, taskDigest: digest(t) })), treatmentOrder: [...AGENT_SUCCESS_RATE_TREATMENT_IDS], config: structuredClone(input.config), components: Object.fromEntries(CAMPAIGN_COMPONENTS.map((key) => [key, { version: "1", digest: values[key] }])) };
+    const contract = input.promptContract ?? null;
+    if (contract !== null) {
+        assertPromptContractShape(contract);
+        campaignAssert(input.config.providerId !== "deterministic-fixture" && contract.providerId === input.config.providerId, "PROMPT_CONTRACT_PROVIDER_MISMATCH");
+    }
+    const body = { schemaVersion: contract === null ? CAMPAIGN_IDENTITY_VERSION : CAMPAIGN_IDENTITY_VERSION_V2, algorithm: "sha256", pluginContract: "agent-success-rate/1.0.0", selected: input.tasks.map((t) => ({ caseId: t.id, projectId: t.benchmarkProject, taskDigest: digest(t) })), treatmentOrder: [...AGENT_SUCCESS_RATE_TREATMENT_IDS], config: structuredClone(input.config), components: Object.fromEntries(CAMPAIGN_COMPONENTS.map((key) => [key, { version: "1", digest: values[key] }])), ...(contract === null ? {} : { promptContract: structuredClone(contract), promptContractDigest: promptContractDigest(contract) }) };
     const result = { ...body, digest: digest(body) };
     validateCampaignIdentity(result);
     return result;
@@ -96,6 +117,10 @@ export function compareCampaignIdentity(left, right) {
     catch {
         return "UNVERIFIABLE";
     }
+    if (left.schemaVersion !== right.schemaVersion)
+        return "MISMATCH";
+    if (left.schemaVersion === CAMPAIGN_IDENTITY_VERSION_V2 && right.schemaVersion === CAMPAIGN_IDENTITY_VERSION_V2 && (canonicalCampaignJson(left.promptContract) !== canonicalCampaignJson(right.promptContract) || left.promptContractDigest !== right.promptContractDigest))
+        return "MISMATCH";
     if (canonicalCampaignJson(left.selected) !== canonicalCampaignJson(right.selected) || canonicalCampaignJson(left.config) !== canonicalCampaignJson(right.config))
         return "MISMATCH";
     let missing = false;

package/dist/src/experiments/plugins/agentSuccessRate/campaignProgress.js

@@ -1,5 +1,6 @@
-import { lstat, readFile, realpath } from "node:fs/promises";
+import { lstat, readFile } from "node:fs/promises";
 import path from "node:path";
+import { isSameOrInside, resolvePhysicalPath } from "../../../evaluation/benchmarkSandbox/pathPolicy.js";
 import { normalizeAgentDurationV091 as normalizedDuration, normalizeAgentTokenUsageV091 as normalizedTokens } from "../../../agents/normalizeAgentTelemetry.js";
 import { validateAgentSuccessRateExecutionArtifact } from "./executionArtifact.js";
 import { validateAgentSuccessRateAnalysisArtifact, validateAgentSuccessRateArtifactFamily } from "./analysisArtifact.js";
@@ -88,7 +89,8 @@ export async function readCampaignProgressScientificFamily(snapshot, boundary) {
     const load = async (name) => {
         const ref = cp.finalization.artifacts.find(a => a.path === name);
         const file = path.join(boundary.outputRoot, name), stat = await lstat(file);
-        campaignAssert(stat.isFile() && !stat.isSymbolicLink() && stat.size === ref.bytes && path.resolve(await realpath(file)).toLowerCase() === path.resolve(file).toLowerCase(), "SCIENTIFIC_ARTIFACT_UNSAFE");
+        const [physicalRoot, physicalFile] = await Promise.all([resolvePhysicalPath(boundary.outputRoot), resolvePhysicalPath(file)]);
+        campaignAssert(stat.isFile() && !stat.isSymbolicLink() && stat.size === ref.bytes && isSameOrInside(physicalRoot, physicalFile) && path.dirname(physicalFile) === physicalRoot, "SCIENTIFIC_ARTIFACT_UNSAFE");
         const bytes = await readFile(file);
         campaignAssert(bytes.length === ref.bytes && campaignHash(bytes) === ref.sha256, "SCIENTIFIC_ARTIFACT_CHANGED");
         return JSON.parse(bytes.toString("utf8"));

package/dist/src/experiments/plugins/agentSuccessRate/campaignResumableExecution.js

@@ -119,7 +119,7 @@ export async function executeResumableCampaign(prepared, args) {
             campaignAssert(provider.kind === "deterministic-fixture" || contexts !== null, "PROVIDER_CONTEXT_REQUIRED");
             const result = provider.kind !== "deterministic-fixture" && contexts ? await executeAgentSuccessRepairTreatment({ ...common, repair: {
                     providerId: provider.providerId, repairAttempts: provider.repairAttempts,
-                    createProposalSource: ({ attemptNumber, feedback }) => createRealAgentProposalSource({ settings: { providerId: provider.providerId, timeoutMs: provider.timeoutMs, ...(provider.kind === "real-agent" ? { trustedExecutable: provider.trustedExecutable, env: provider.env } : {}), outDir: epochRoot, privateRoots: common.privateRoots, protectedRoots: [boundary.toolRoot, boundary.outputRoot, activeRuntime, canonicalProjectRoot], runAgent: async (request) => {
+                    createProposalSource: ({ attemptNumber, feedback }) => createRealAgentProposalSource({ settings: { providerId: provider.providerId, timeoutMs: provider.timeoutMs, ...(provider.promptContract ? { promptContract: provider.promptContract } : {}), ...(provider.kind === "real-agent" ? { trustedExecutable: provider.trustedExecutable, env: provider.env } : {}), outDir: epochRoot, privateRoots: common.privateRoots, protectedRoots: [boundary.toolRoot, boundary.outputRoot, activeRuntime, canonicalProjectRoot], runAgent: async (request) => {
                                 await fresh();
                                 campaignAssert((await read()).checkpoint?.integrity === claimed.integrity, "STALE_INVOCATION_CLAIM");
                                 await prepareCampaignProviderOutput(boundary, identity, owner, `${epoch.namespace}/${agentSuccessAgentArtifactDirectory(unit.task.benchmarkProject, unit.task.id, unit.treatmentId, attemptNumber)}`);

package/dist/src/experiments/plugins/agentSuccessRate/config.js

@@ -2,12 +2,37 @@ import { parseCommandString } from "../../../core/commandLine.js";
 import { invalidExperimentConfig, isPlainObject, mergeConfig, validExperimentConfig } from "../../config.js";
 import { DEFAULT_AGENT_SUCCESS_KIT_COMMAND } from "./contextGeneration.js";
 import { AGENT_SUCCESS_RATE_MAX_AGENT_TIMEOUT_MS } from "./realAgentExecution.js";
+import { createPromptContract } from "./promptContract.js";
+import { AGENT_SUCCESS_PROMPT_EXPLANATION_MODES, AGENT_SUCCESS_PROMPT_LENGTH_MODES, AGENT_SUCCESS_PROMPT_TEMPLATE_IDS, AGENT_SUCCESS_PROMPT_TOOL_USE_MODES } from "./realAgentPrompt.js";
 export const AGENT_SUCCESS_RATE_REAL_AGENT_IDS = ["codex", "claude"];
+const PROMPT_FIELD_ALLOWED_VALUES = {
+    promptTemplate: AGENT_SUCCESS_PROMPT_TEMPLATE_IDS,
+    promptLength: AGENT_SUCCESS_PROMPT_LENGTH_MODES,
+    promptExplanation: AGENT_SUCCESS_PROMPT_EXPLANATION_MODES,
+    promptToolUse: AGENT_SUCCESS_PROMPT_TOOL_USE_MODES
+};
+const PROMPT_FIELDS = [...Object.keys(PROMPT_FIELD_ALLOWED_VALUES), "maxCommandCount"];
+/** True when any prompt-contract option was explicitly supplied (even with its default value). */
+export function hasExplicitPromptContractSelection(config) {
+    return PROMPT_FIELDS.some((field) => config[field] !== undefined);
+}
+/** The explicit prompt contract for a validated real-agent config, or null when no prompt option was supplied. */
+export function resolveAgentSuccessPromptContract(config) {
+    if (config.agentId === undefined || !hasExplicitPromptContractSelection(config))
+        return null;
+    return createPromptContract(config.agentId, {
+        ...(config.promptTemplate !== undefined ? { templateId: config.promptTemplate } : {}),
+        ...(config.promptLength !== undefined ? { lengthMode: config.promptLength } : {}),
+        ...(config.promptExplanation !== undefined ? { explanationMode: config.promptExplanation } : {}),
+        ...(config.promptToolUse !== undefined ? { toolUseMode: config.promptToolUse } : {}),
+        ...(config.maxCommandCount !== undefined ? { maxCommandCount: config.maxCommandCount } : {})
+    });
+}
 export const AGENT_SUCCESS_RATE_REPAIR_ATTEMPT_VALUES = [0, 1, 2];
 export const defaultAgentSuccessRateConfig = {
     outDir: "lab-output/agent-success-rate"
 };
-const SUPPORTED_FIELDS = ["outDir", "caseIds", "benchmarkProjects", "agentId", "includeRealAgents", "timeoutMs", "kitCommand", "repairAttempts"];
+const SUPPORTED_FIELDS = ["outDir", "caseIds", "benchmarkProjects", "agentId", "includeRealAgents", "timeoutMs", "kitCommand", "repairAttempts", ...PROMPT_FIELDS];
 /** Names that are recognized only to give a precise rejection. */
 const REJECTED_FIELD_MESSAGES = {
     commandTemplate: "commandTemplate is not supported; real providers use the fixed adapter invocation.",
@@ -31,7 +56,12 @@ export const agentSuccessRateConfigDefinition = {
         { name: "includeRealAgents", type: "boolean", description: "Must be exactly true whenever agentId is set; rejected otherwise." },
         { name: "timeoutMs", type: "number", description: "Per-attempt provider timeout in ms (real-agent mode only)." },
         { name: "kitCommand", type: "string", description: "my-dev-kit command used for context-pack retrieval (real-agent mode only)." },
-        { name: "repairAttempts", type: "number", description: "Repairs allowed after the initial attempt: 0 (default), 1 or 2. Real-agent mode only; at most 3 attempts per treatment." }
+        { name: "repairAttempts", type: "number", description: "Repairs allowed after the initial attempt: 0 (default), 1 or 2. Real-agent mode only; at most 3 attempts per treatment." },
+        { name: "promptTemplate", type: "string", description: "Prompt template: legacy-diff-v1 (default) or strict-diff-v1. Real-agent mode only." },
+        { name: "promptLength", type: "string", description: "Prompt length: standard (default) or short. Real-agent mode only." },
+        { name: "promptExplanation", type: "string", description: "Explanation policy: legacy (default) or none. Real-agent mode only." },
+        { name: "promptToolUse", type: "string", description: "Tool-use statement: prohibited (default) or bounded (explicit zero command budget). Real-agent mode only." },
+        { name: "maxCommandCount", type: "number", description: "Maximum command count guidance; only 0 is accepted. Real-agent mode only." }
     ]
 };
 export function validateAgentSuccessRateConfig(config) {
@@ -116,6 +146,21 @@ export function validateAgentSuccessRateConfig(config) {
             normalized.kitCommand = DEFAULT_AGENT_SUCCESS_KIT_COMMAND;
         }
     }
+    const suppliedPromptFields = PROMPT_FIELDS.filter((field) => raw[field] !== undefined);
+    if (suppliedPromptFields.length > 0) {
+        if (agentId === undefined || raw.includeRealAgents !== true) {
+            errors.push(`${suppliedPromptFields.join(", ")} require real-agent mode (agentId together with includeRealAgents=true); prompt options never enable a provider.`);
+        }
+        for (const [field, allowed] of Object.entries(PROMPT_FIELD_ALLOWED_VALUES)) {
+            const value = raw[field];
+            if (value !== undefined && !(typeof value === "string" && allowed.includes(value))) {
+                errors.push(`${field} must be one of: ${allowed.join(", ")}.`);
+            }
+        }
+        if (raw.maxCommandCount !== undefined && !(typeof raw.maxCommandCount === "number" && Number.isInteger(raw.maxCommandCount) && raw.maxCommandCount === 0)) {
+            errors.push("maxCommandCount must be the integer 0; the benchmark permits no commands.");
+        }
+    }
     return errors.length > 0 ? invalidExperimentConfig(errors) : validExperimentConfig(normalized);
 }
 function isRepairAttemptsValue(value) {

package/dist/src/experiments/plugins/agentSuccessRate/plugin.js

@@ -9,7 +9,7 @@ import { summarizeExperimentRun } from "../../results.js";
 import { analyzeAgentSuccessRate } from "./analysis.js";
 import { projectAgentFacingTask } from "./agentTaskProjection.js";
 import { AGENT_SUCCESS_RATE_ANALYSIS_ARTIFACT_FILE, buildAgentSuccessRateAnalysisArtifact, validateAgentSuccessRateAnalysisArtifact, validateAgentSuccessRateArtifactFamily } from "./analysisArtifact.js";
-import { agentSuccessRateConfigDefinition, defaultAgentSuccessRateConfig, validateAgentSuccessRateConfig } from "./config.js";
+import { agentSuccessRateConfigDefinition, defaultAgentSuccessRateConfig, resolveAgentSuccessPromptContract, validateAgentSuccessRateConfig } from "./config.js";
 import { AgentSuccessPackContextBuilder, DEFAULT_AGENT_SUCCESS_KIT_COMMAND, buildContextTaskInput, buildRawFullFileContext, collectForbiddenAgentValues } from "./contextGeneration.js";
 import { AGENT_SUCCESS_RATE_SELF_ONLY_MESSAGE, AgentSuccessRateInputError, boundMessage, executeAgentSuccessCase, readAgentSuccessTasksInput, resolveControlledBenchmarkProject, resolveSandboxRuntimeRoot, selectAgentSuccessTasks } from "./execution.js";
 import { AGENT_SUCCESS_RATE_EXECUTION_ARTIFACT_FILE, buildAgentSuccessRateExecutionArtifact, validateAgentSuccessRateExecutionArtifact } from "./executionArtifact.js";
@@ -83,6 +83,7 @@ export const agentSuccessRatePlugin = {
                 timeoutMs: real.timeoutMs,
                 env: readAgentEnvInput(inputs),
                 runAgent: readRunAgentInput(inputs),
+                ...(real.promptContract ? { promptContract: real.promptContract } : {}),
                 outDir,
                 protectedRoots: [context.toolRoot, outDir, runtimeRoot, packageRoot(), ...projectRoots.values()],
                 privateRoots: [outDir, context.toolRoot],
@@ -399,7 +400,8 @@ function readRealAgentConfig(config) {
         providerId: config.agentId,
         timeoutMs: config.timeoutMs ?? AGENT_SUCCESS_RATE_DEFAULT_AGENT_TIMEOUT_MS,
         kitCommand: config.kitCommand ?? DEFAULT_AGENT_SUCCESS_KIT_COMMAND,
-        repairAttempts: config.repairAttempts ?? 0
+        repairAttempts: config.repairAttempts ?? 0,
+        promptContract: resolveAgentSuccessPromptContract(config)
     };
 }
 /** Captures hidden values for the leak guard, then returns a copy of the task with the reference fixture removed. */

package/dist/src/experiments/plugins/agentSuccessRate/promptContract.js

@@ -0,0 +1,121 @@
+import { createHash } from "node:crypto";
+import { AGENT_SUCCESS_PROMPT_EXPLANATION_MODES, AGENT_SUCCESS_PROMPT_LENGTH_MODES, AGENT_SUCCESS_PROMPT_TEMPLATE_IDS, AGENT_SUCCESS_PROMPT_TOOL_USE_MODES, REAL_AGENT_CONTEXT_BEGIN, REAL_AGENT_CONTEXT_END, describeAgentSuccessPromptInstructions, isLegacyDefaultPromptSettings } from "./realAgentPrompt.js";
+/**
+ * PromptContractV1 is the typed, persisted identity of the effective patch-generation prompt for one provider. It is
+ * deliberately separate from the context-treatment identity (raw-full-file / context-pack): that identity names the
+ * context transport, this one names the instruction template. It never carries source/context bodies, trusted checks
+ * or provider output.
+ */
+export const PROMPT_CONTRACT_SCHEMA_VERSION = "1.0.0";
+export const PROMPT_CONTRACT_ARTIFACT_FILE = "prompt-contract.json";
+const CONTRACT_FIELDS = ["schemaVersion", "templateId", "providerId", "lengthMode", "explanationMode", "toolUseMode", "maxCommandCount", "rendererDigest"];
+function sha256(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+/** Sorted-key canonical JSON for flat, finite, string/number/array/object data (the only shapes this module hashes). */
+function canonicalJson(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
+        .join(",")}}`;
+}
+/**
+ * Digest of the normalized, versioned template definition: the effective settings plus the exact instruction lines and
+ * context delimiters the renderer emits for them. It never reads task data, the answer key or hidden checks.
+ */
+export function computePromptRendererDigest(settings) {
+    return sha256(canonicalJson({
+        definition: "my-dev-kit-lab-agent-success-rate-prompt-template-v1",
+        settings: {
+            templateId: settings.templateId,
+            providerId: settings.providerId,
+            lengthMode: settings.lengthMode,
+            explanationMode: settings.explanationMode,
+            toolUseMode: settings.toolUseMode,
+            maxCommandCount: settings.maxCommandCount
+        },
+        delimiters: [REAL_AGENT_CONTEXT_BEGIN, REAL_AGENT_CONTEXT_END],
+        instructions: describeAgentSuccessPromptInstructions(settings)
+    }));
+}
+/** Normalizes a selection (omitted fields take the inherited defaults) into a complete contract. */
+export function createPromptContract(providerId, selection = {}) {
+    const settings = {
+        templateId: selection.templateId ?? "legacy-diff-v1",
+        providerId,
+        lengthMode: selection.lengthMode ?? "standard",
+        explanationMode: selection.explanationMode ?? "legacy",
+        toolUseMode: selection.toolUseMode ?? "prohibited",
+        maxCommandCount: selection.maxCommandCount ?? 0
+    };
+    const contract = {
+        schemaVersion: PROMPT_CONTRACT_SCHEMA_VERSION,
+        templateId: settings.templateId,
+        providerId,
+        lengthMode: settings.lengthMode,
+        explanationMode: settings.explanationMode,
+        toolUseMode: settings.toolUseMode,
+        maxCommandCount: 0,
+        rendererDigest: computePromptRendererDigest(settings)
+    };
+    assertPromptContractShape(contract);
+    return contract;
+}
+/** Throws on unknown fields, missing fields or out-of-vocabulary values. Does not recompute the renderer digest. */
+export function assertPromptContractShape(value) {
+    const fail = (reason) => {
+        throw new Error(`INVALID_PROMPT_CONTRACT: ${reason}`);
+    };
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        fail("not an object");
+    const record = value;
+    const keys = Object.keys(record).sort();
+    if (keys.join("\0") !== [...CONTRACT_FIELDS].sort().join("\0"))
+        fail("fields are not exactly the PromptContractV1 fields");
+    if (record.schemaVersion !== PROMPT_CONTRACT_SCHEMA_VERSION)
+        fail("unsupported schemaVersion");
+    if (!AGENT_SUCCESS_PROMPT_TEMPLATE_IDS.includes(record.templateId))
+        fail("unknown templateId");
+    if (record.providerId !== "codex" && record.providerId !== "claude")
+        fail("unknown providerId");
+    if (!AGENT_SUCCESS_PROMPT_LENGTH_MODES.includes(record.lengthMode))
+        fail("unknown lengthMode");
+    if (!AGENT_SUCCESS_PROMPT_EXPLANATION_MODES.includes(record.explanationMode))
+        fail("unknown explanationMode");
+    if (!AGENT_SUCCESS_PROMPT_TOOL_USE_MODES.includes(record.toolUseMode))
+        fail("unknown toolUseMode");
+    if (record.maxCommandCount !== 0)
+        fail("maxCommandCount must be 0");
+    if (typeof record.rendererDigest !== "string" || !/^[a-f0-9]{64}$/.test(record.rendererDigest))
+        fail("invalid rendererDigest");
+}
+/** True when the contract's renderer digest equals the digest the current renderer produces for its settings. */
+export function promptContractMatchesCurrentRenderer(contract) {
+    return contract.rendererDigest === computePromptRendererDigest(promptSettingsOf(contract));
+}
+export function promptSettingsOf(contract) {
+    return {
+        templateId: contract.templateId,
+        providerId: contract.providerId,
+        lengthMode: contract.lengthMode,
+        explanationMode: contract.explanationMode,
+        toolUseMode: contract.toolUseMode,
+        maxCommandCount: contract.maxCommandCount
+    };
+}
+export function promptContractDigest(contract) {
+    assertPromptContractShape(contract);
+    return sha256(canonicalJson(contract));
+}
+export function isLegacyDefaultPromptContract(contract) {
+    return isLegacyDefaultPromptSettings(contract);
+}
+/** Exact bytes of the per-attempt prompt-contract.json artifact; deterministic, so recovery can recompute and compare. */
+export function renderPromptContractArtifact(contract) {
+    return `${canonicalJson({ promptContract: contract, promptContractDigest: promptContractDigest(contract) })}\n`;
+}

package/dist/src/experiments/plugins/agentSuccessRate/realAgentExecution.js

@@ -1,4 +1,4 @@
-import { mkdtemp, readdir, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { normalizeAgentDurationV091, normalizeAgentTokenUsageV091 } from "../../../agents/index.js";
@@ -9,6 +9,8 @@ import { sanitizePathSegment } from "../../outputPaths.js";
 import { findPromptLeaks } from "./contextGeneration.js";
 import { boundMessage } from "./execution.js";
 import { buildAgentSuccessRealAgentPrompt } from "./realAgentPrompt.js";
+import { PROMPT_CONTRACT_ARTIFACT_FILE, createPromptContract, promptSettingsOf, renderPromptContractArtifact } from "./promptContract.js";
+import { validateAgentSuccessFinalAnswer } from "./strictDiffResponse.js";
 import { summarizeAgentSuccessRepairFeedback } from "./repairFeedback.js";
 export const AGENT_SUCCESS_RATE_DEFAULT_AGENT_TIMEOUT_MS = 240_000;
 export const AGENT_SUCCESS_RATE_MAX_AGENT_TIMEOUT_MS = 1_800_000;
@@ -109,6 +111,9 @@ async function assertNeutralCwd(cwd, protectedRoots) {
  */
 export function createRealAgentProposalSource(args) {
     const { settings } = args;
+    const promptContract = settings.promptContract ?? createPromptContract(settings.providerId);
+    if (promptContract.providerId !== settings.providerId)
+        throw new Error("PROMPT_CONTRACT_PROVIDER_MISMATCH");
     const attemptNumber = args.attemptNumber ?? 1;
     return async ({ treatmentId, invoke, notInvokedReason }) => {
         let runtimeTelemetry = projectAgentSuccessProviderTelemetryV091(null, "not-invoked", null);
@@ -165,6 +170,7 @@ export function createRealAgentProposalSource(args) {
             task,
             treatmentId,
             contextText: context.text,
+            prompt: promptSettingsOf(promptContract),
             ...(args.repair ? { repair: { feedback: args.repair.feedback, attemptNumber, maxAttempts: args.repair.maxAttempts } } : {})
         });
         const leaks = findPromptLeaks(promptText, args.forbidden);
@@ -256,6 +262,14 @@ export function createRealAgentProposalSource(args) {
         const agentDurationMs = Number.isFinite(result.durationMs) && result.durationMs >= 0 ? result.durationMs : Date.now() - wallStarted;
         const agentTokenUsage = tokenEvidence(result);
         runtimeTelemetry = projectAgentSuccessProviderTelemetryV091(result, providerStatus, agentDurationMs);
+        // The effective contract is persisted next to the provider artifacts so recovery can prove which prompt produced them.
+        try {
+            await mkdir(attemptAbsolute, { recursive: true });
+            await writeFile(path.join(attemptAbsolute, PROMPT_CONTRACT_ARTIFACT_FILE), renderPromptContractArtifact(promptContract), { encoding: "utf8", flag: "wx" });
+        }
+        catch {
+            return noProposal("prompt-contract-not-persisted", "PROMPT_CONTRACT_NOT_PERSISTED", "The effective prompt contract could not be persisted; the provider answer was not evaluated.");
+        }
         if (providerStatus !== "completed") {
             return noProposal(classification.statusReason, PROVIDER_STATUS_CODES[providerStatus] ?? "PROVIDER_FAILED", `Provider ${settings.providerId} ended with status ${providerStatus}: ${classification.statusReason}`, {
                 agentDurationMs,
@@ -267,6 +281,22 @@ export function createRealAgentProposalSource(args) {
         }
         realAgent.finalAnswerAvailable = true;
         realAgent.providerStatusReason = null;
-        return { kind: "proposal", ...runtimeTelemetry, text: result.finalAnswerText, realAgent, agentDurationMs, agentTokenUsage, errors: [], contextFile };
+        // Application-level output contract, applied only to a completed provider's extracted final answer. An invalid
+        // response is handed to the patch pipeline as an empty proposal: it is recorded as malformed, never re-interpreted
+        // through legacy extraction, and the diagnostic reason code is retained as a bounded error.
+        const output = validateAgentSuccessFinalAnswer(promptContract, result.finalAnswerText);
+        if (!output.ok) {
+            return {
+                kind: "proposal",
+                ...runtimeTelemetry,
+                text: "",
+                realAgent,
+                agentDurationMs,
+                agentTokenUsage,
+                errors: [{ code: `OUTPUT_CONTRACT_${output.code}`, message: `The provider final answer violated the ${promptContract.templateId} output contract (${output.code}).` }],
+                contextFile
+            };
+        }
+        return { kind: "proposal", ...runtimeTelemetry, text: output.patchText, realAgent, agentDurationMs, agentTokenUsage, errors: [], contextFile };
     };
 }