@dailephd/my-dev-kit-lab 0.9.2 → 0.9.4

package/dist/src/evaluation/affectedNeighborhood.js

@@ -4,7 +4,13 @@ import { compareCodeUnits, interpretIndexManifest, readJson } from "./indexSnaps
 export const AFFECTED_NEIGHBORHOOD_GRAPH_EVIDENCE_SCHEMA_VERSION = "my-dev-kit-lab-affected-neighborhood-graph-evidence-v1";
 export const AFFECTED_NEIGHBORHOOD_SEED_MAPPING_SCHEMA_VERSION = "my-dev-kit-lab-affected-neighborhood-seed-mapping-v1";
 const MANIFEST_FILE = "manifest.json";
-const SUPPORTED_SYMBOL_INDEX_SCHEMA_VERSION = "2";
+/**
+ * Schema 2 (my-dev-kit 1.13.x) identifies a symbol by file path + name. Schema 3 (my-dev-kit 1.14.x)
+ * additionally persists each symbol's actual graph `nodeId`, which may be a distinct `symbolq:` identity
+ * for same-named members. Both are understood; anything else is rejected.
+ */
+const SUPPORTED_SYMBOL_INDEX_SCHEMA_VERSIONS = ["2", "3"];
+const SCHEMA_WITH_PERSISTED_SYMBOL_NODE_IDS = "3";
 const SUPPORTED_CODE_GRAPH_ARTIFACT_KIND = "code-graph";
 const SUPPORTED_CODE_GRAPH_VERSION_PATTERN = /^1\./;
 // Same bounds as the v0.6.0 freshness/snapshot evidence lists.
@@ -57,18 +63,23 @@ function sortWarnings(warnings) {
     return [...warnings].sort((left, right) => compareCodeUnits(left.code, right.code) || compareCodeUnits(left.subject ?? "", right.subject ?? "") || compareCodeUnits(left.message, right.message));
 }
 /**
- * Policy: reads indexed-file membership and baseline symbols from a symbol-index artifact. Only
- * schema version 2 is understood. A file entry whose symbol list is malformed keeps its
- * membership but yields no symbol record; a malformed symbol entry is dropped with a warning.
- * Pure.
+ * Policy: reads indexed-file membership and baseline symbol identities from a symbol-index artifact.
+ * Schema versions 2 and 3 are understood; anything else is unsupported. Under schema 2 a symbol's
+ * identity is its upstream file+name node ID. Under schema 3 it is the `nodeId` the index persisted,
+ * which is never reconstructed from the simple name: same-named members keep distinct identities,
+ * and a record without a usable `nodeId` stays visible as an unmappable identity with a warning
+ * instead of receiving a guessed one. A file entry whose symbol list is malformed keeps its
+ * membership but yields no symbol record; a malformed symbol entry is dropped with a warning. Pure.
  */
 export function interpretSymbolIndexForNeighborhood(symbolIndex) {
     if (!isRecord(symbolIndex)) {
         return { ok: false, message: "Symbol index is not a JSON object." };
     }
-    if (symbolIndex.schemaVersion !== SUPPORTED_SYMBOL_INDEX_SCHEMA_VERSION) {
-        return { ok: false, message: `Symbol index schemaVersion is not the supported ${SUPPORTED_SYMBOL_INDEX_SCHEMA_VERSION}.` };
+    const schemaVersion = symbolIndex.schemaVersion;
+    if (typeof schemaVersion !== "string" || !SUPPORTED_SYMBOL_INDEX_SCHEMA_VERSIONS.includes(schemaVersion)) {
+        return { ok: false, message: `Symbol index schemaVersion is not a supported version (${SUPPORTED_SYMBOL_INDEX_SCHEMA_VERSIONS.join(", ")}).` };
     }
+    const persistsNodeIds = schemaVersion === SCHEMA_WITH_PERSISTED_SYMBOL_NODE_IDS;
     if (!Array.isArray(symbolIndex.files)) {
         return { ok: false, message: "Symbol index does not list indexed files." };
     }
@@ -92,29 +103,57 @@ export function interpretSymbolIndexForNeighborhood(symbolIndex) {
             });
             continue;
         }
-        const seen = new Set();
+        const identities = new Map();
         const duplicates = new Set();
+        const missingNodeIdNames = new Set();
         for (const symbol of entry.symbols) {
             if (!isRecord(symbol) || !nonEmptyString(symbol.name)) {
                 warnings.push({ code: "invalid-symbol-entry", subject: boundedText(filePath), message: "Symbol index entry lacks a symbol name and was ignored." });
                 continue;
             }
-            if (seen.has(symbol.name)) {
-                duplicates.add(symbol.name);
+            const name = symbol.name;
+            let identity;
+            let identityKey;
+            if (!persistsNodeIds) {
+                identity = { name, nodeId: symbolNodeId(filePath, name), persisted: false };
+                identityKey = identity.nodeId;
+            }
+            else if (nonEmptyString(symbol.nodeId)) {
+                identity = { name, nodeId: symbol.nodeId, persisted: true };
+                identityKey = `id:${symbol.nodeId}`;
             }
-            seen.add(symbol.name);
+            else {
+                // No persisted identity: one unmappable identity per name, never a reconstructed one.
+                identity = { name, nodeId: null, persisted: true };
+                identityKey = `missing:${name}`;
+                missingNodeIdNames.add(name);
+            }
+            if (identities.has(identityKey)) {
+                duplicates.add(name);
+                continue;
+            }
+            identities.set(identityKey, identity);
         }
-        records.set(filePath, {
-            symbolNames: [...seen].sort(compareCodeUnits),
-            duplicateSymbolNames: [...duplicates].sort(compareCodeUnits),
-        });
+        for (const name of [...missingNodeIdNames].sort(compareCodeUnits)) {
+            warnings.push({
+                code: "symbol-node-id-missing",
+                subject: boundedText(`${filePath}#${name}`),
+                message: "Schema-3 symbol record has no usable persisted nodeId; its identity is not guessed and it cannot be mapped to a graph node.",
+            });
+        }
+        const sortedRecords = [...identities.values()].sort((left, right) => compareCodeUnits(left.nodeId ?? "", right.nodeId ?? "") || compareCodeUnits(left.name, right.name));
+        const names = [...new Set(sortedRecords.map((record) => record.name))].sort(compareCodeUnits);
+        const sameName = names.filter((name) => sortedRecords.filter((record) => record.name === name).length > 1);
+        // Schema-2 evidence keeps its original shape: each name is its only identity, so no per-record data is added.
+        const fileRecord = { symbolNames: names, duplicateSymbolNames: [...duplicates].sort(compareCodeUnits) };
+        records.set(filePath, persistsNodeIds ? { ...fileRecord, records: sortedRecords, sameNameSymbolNames: sameName } : fileRecord);
     }
     const indexedFilePaths = [...paths].sort(compareCodeUnits);
     const symbolFiles = new Map();
     for (const key of [...records.keys()].sort(compareCodeUnits)) {
         symbolFiles.set(key, records.get(key));
     }
-    return { ok: true, value: { indexedFilePaths, symbolFiles, warnings } };
+    return { ok: true, value: { schemaVersion, indexedFilePaths, symbolFiles, warnings } };
 }
 /**
  * Policy: validates the structure of a code-graph artifact and preserves its nodes and edges by
@@ -234,7 +273,7 @@ export async function loadAffectedNeighborhoodGraphEvidence(options) {
         }
         const symbolIndexSummary = {
             path: normalizePath(path.relative(path.resolve(indexDir), symbolIndexFile)),
-            schemaVersion: SUPPORTED_SYMBOL_INDEX_SCHEMA_VERSION,
+            schemaVersion: symbols.value.schemaVersion,
         };
         const warnings = [...symbols.value.warnings];
         let codeGraphSummary = null;
@@ -310,10 +349,35 @@ function lookupNode(evidence, expectedNodeId, kind) {
 export function lookupFileNode(evidence, filePath) {
     return lookupNode(evidence, fileNodeId(filePath), "file");
 }
-/** Same-file symbol lookup. Never searches for a same-named symbol in another file. */
+/**
+ * Same-file symbol lookup by the upstream file+name identity. Never searches for a same-named symbol
+ * in another file. This is the schema-2 identity only; it does not find a qualified (`symbolq:`) member.
+ */
 export function lookupSymbolNode(evidence, filePath, symbolName) {
     return lookupNode(evidence, symbolNodeId(filePath, symbolName), "symbol");
 }
+/**
+ * Exact lookup of one baseline symbol identity. The node must exist under the identity the index
+ * actually recorded, be a `symbol` node, and (when the graph names a path) belong to the same
+ * file; otherwise it is unresolved. A record without a persisted identity is never mapped, and no
+ * identity is derived from its name.
+ */
+export function lookupSymbolRecordNode(evidence, filePath, record) {
+    if (record.nodeId === null)
+        return { ok: false, expectedNodeId: "", reason: "symbol-node-id-missing" };
+    const lookup = lookupNode(evidence, record.nodeId, "symbol");
+    if (!lookup.ok)
+        return lookup;
+    const node = evidence.nodes.get(lookup.nodeId);
+    if (node && node.path !== null && normalizePath(node.path) !== filePath) {
+        return { ok: false, expectedNodeId: record.nodeId, reason: "graph-node-path-mismatch" };
+    }
+    return lookup;
+}
+/** The baseline identities of one indexed file; evidence without per-record data keeps the schema-2 file+name identity. */
+function symbolRecordsOf(filePath, file) {
+    return file.records ?? file.symbolNames.map((name) => ({ name, nodeId: symbolNodeId(filePath, name), persisted: false }));
+}
 /**
  * Maps confirmed changed indexed files, and the baseline symbols belonging to them, onto baseline
  * graph nodes. Pure and deterministic: consumes only the v0.6.0 snapshot and freshness assessment
@@ -404,18 +468,21 @@ export function mapAffectedNeighborhoodSeeds(input) {
             continue;
         }
         if (record.duplicateSymbolNames.length > 0) {
-            warn("duplicate-symbol-records", `Baseline symbol index lists ${record.duplicateSymbolNames.length} symbol name(s) more than once; each counts as one identity.`, filePath);
+            warn("duplicate-symbol-records", `Baseline symbol index repeats ${record.duplicateSymbolNames.length} identical symbol record(s); each counts as one identity.`, filePath);
         }
-        for (const name of record.symbolNames) {
+        // Each distinct baseline identity is a seed in its own right: same-named members that the index
+        // persisted with different node IDs are never merged, and none is reconstructed from the name.
+        for (const identity of symbolRecordsOf(filePath, record)) {
+            const name = identity.name;
             symbolIdentityCount += 1;
-            const symbolExpectedId = symbolNodeId(filePath, name);
+            const symbolExpectedId = identity.nodeId ?? "";
             let symbolResolvedId = null;
             let symbolReason = null;
             if (!codeGraphLoaded) {
                 symbolReason = "graph-unavailable";
             }
             else {
-                const lookup = lookupSymbolNode(graph, filePath, name);
+                const lookup = lookupSymbolRecordNode(graph, filePath, identity);
                 if (lookup.ok)
                     symbolResolvedId = lookup.nodeId;
                 else
@@ -426,7 +493,12 @@ export function mapAffectedNeighborhoodSeeds(input) {
                 seeds.add(symbolResolvedId);
             }
             else {
-                unresolved.push({ subject: "changed-symbol", path: boundedText(filePath), name: boundedText(name), reason: symbolReason });
+                unresolved.push({
+                    subject: "changed-symbol",
+                    path: boundedText(filePath),
+                    name: boundedText(name),
+                    reason: symbolReason,
+                });
             }
             changedSymbols.push({
                 path: filePath,
@@ -490,11 +562,41 @@ function uniqueSorted(values) {
 function normalizeExpectedPath(value) {
     return normalizePath(value).replace(/^(\.\/)+/, "");
 }
+/**
+ * Candidate graph nodes for one expected symbol in one expected file. A request matches a baseline
+ * identity by its simple name or by that identity's exact persisted node ID; every matching identity
+ * is a distinct candidate (same-named members are never collapsed). A file the symbol index has no
+ * record for keeps the schema-2 file+name lookup. Nothing is derived from the name beyond that.
+ */
+function resolveExpectedSymbolInFile(graph, filePath, request) {
+    const file = graph.symbolFiles.get(filePath);
+    if (!file) {
+        const lookup = lookupSymbolNode(graph, filePath, request);
+        return { nodeIds: lookup.ok ? [lookup.nodeId] : [], identityMissing: false, pathMismatch: !lookup.ok && lookup.reason === "graph-node-path-mismatch" };
+    }
+    const nodeIds = [];
+    let identityMissing = false;
+    let pathMismatch = false;
+    for (const identity of symbolRecordsOf(filePath, file)) {
+        if (identity.name !== request && identity.nodeId !== request)
+            continue;
+        const lookup = lookupSymbolRecordNode(graph, filePath, identity);
+        if (lookup.ok)
+            nodeIds.push(lookup.nodeId);
+        else if (lookup.reason === "symbol-node-id-missing")
+            identityMissing = true;
+        else if (lookup.reason === "graph-node-path-mismatch")
+            pathMismatch = true;
+    }
+    return { nodeIds, identityMissing, pathMismatch };
+}
 /**
  * Policy: maps a task's expected files and symbols to baseline graph nodes. Files resolve only to
  * their exact `file:` node. A symbol resolves only within the task's own expected files and only
- * when exactly one same-name node exists there; zero matches is unresolved and several is
- * ambiguous (no winner is picked, no node is added). Never searches the rest of the graph. Pure.
+ * when exactly one matching identity exists there; zero matches is unresolved and several (in one
+ * file or across files, including same-named members with distinct persisted node IDs) is
+ * ambiguous (no winner is picked, no node is added). A request that is itself a persisted node ID
+ * resolves to exactly that identity. Never searches the rest of the graph. Pure.
  */
 export function mapAffectedNeighborhoodTask(input) {
     const { graph } = input;
@@ -561,15 +663,21 @@ export function mapAffectedNeighborhoodTask(input) {
     const resolvedSymbols = [];
     for (const name of expectedSymbols) {
         // Scope is the task's expected files, whether or not their own file node resolved.
-        const candidates = uniqueSorted(expectedFiles.flatMap((filePath) => {
-            const lookup = lookupSymbolNode(graph, filePath, name);
-            return lookup.ok ? [lookup.nodeId] : [];
-        }));
-        if (candidates.length === 1) {
+        const found = expectedFiles.map((filePath) => resolveExpectedSymbolInFile(graph, filePath, name));
+        const candidates = uniqueSorted(found.flatMap((entry) => entry.nodeIds));
+        // A same-name identity that persisted no node ID cannot be excluded, so a lone mappable candidate
+        // is not trusted as "the" owner when such a sibling exists.
+        const identityMissing = found.some((entry) => entry.identityMissing);
+        if (candidates.length === 1 && !identityMissing) {
             resolvedSymbols.push({ name, nodeId: candidates[0] });
         }
-        else if (candidates.length === 0) {
-            unresolved.push({ subject: "expected-symbol", name: boundedText(name), reason: "graph-node-missing" });
+        else if (candidates.length <= 1) {
+            const reason = identityMissing
+                ? "symbol-node-id-missing"
+                : found.some((entry) => entry.pathMismatch)
+                    ? "graph-node-path-mismatch"
+                    : "graph-node-missing";
+            unresolved.push({ subject: "expected-symbol", name: boundedText(name), reason });
         }
         else {
             ambiguous.push({ name: boundedText(name), candidateNodeIds: candidates });

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";
@@ -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/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. */