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

package/dist/src/commands/runExperimentRunCommand.js

@@ -1,4 +1,4 @@
-import { readFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, readdir, realpath } from "node:fs/promises";
 import path from "node:path";
 import { parseAgentCommandTemplate } from "../agents/index.js";
 import { parseAgentId } from "../agents/agentRegistry.js";
@@ -17,6 +17,18 @@ import { parsePromptComplexityLevel, parsePromptStrategy } from "../prompts/inde
 import { writePluginExperimentReports } from "../report/index.js";
 import { createLabExecutionContext, resolvePackageResource } from "../runtime/index.js";
 import { runWarmIndexCampaignPresentation } from "./runWarmIndexCampaignPresentation.js";
+import { observeProviderBuild } from "../agents/providerBuildObservation.js";
+import { resolveAgentTimeoutPreset } from "../experiments/plugins/agentSuccessRate/timeoutPresets.js";
+import { validateAgentSuccessRateConfig } from "../experiments/plugins/agentSuccessRate/config.js";
+import { AGENT_SUCCESS_RATE_DEFAULT_AGENT_TIMEOUT_MS } from "../experiments/plugins/agentSuccessRate/realAgentExecution.js";
+import { AGENT_SUCCESS_RATE_TREATMENT_IDS } from "../experiments/plugins/agentSuccessRate/metadata.js";
+import { executeAgentSuccessCampaignV2, prepareAgentSuccessCampaign } from "../experiments/plugins/agentSuccessRate/campaignExecution.js";
+import { readCampaignCheckpointV2, validateCampaignOutputPath } from "../experiments/plugins/agentSuccessRate/campaignCheckpointStore.js";
+import { validateCampaignLimitAuthorization } from "../experiments/plugins/agentSuccessRate/campaignRecovery.js";
+import { campaignIdentifier } from "../experiments/plugins/agentSuccessRate/campaignIdentity.js";
+import { readCampaignProgress } from "../experiments/plugins/agentSuccessRate/campaignProgress.js";
+import { writeAgentSuccessCampaignProgressReport } from "../report/experiments/writeAgentSuccessCampaignProgressReport.js";
+import { boundMessage } from "../experiments/plugins/agentSuccessRate/execution.js";
 // ---------------------------------------------------------------------------
 // v0.4.6 Batch 4 -- reusable experiment-run command owner.
 //
@@ -85,8 +97,11 @@ const AGENT_SUCCESS_RATE_ALLOWED_FLAGS = [
     "--agent",
     "--include-real-agents",
     "--timeout-ms",
-    "--repair-attempts"
+    "--repair-attempts",
+    "--agent-campaign", "--one-case", "--campaign-source-root", "--timeout-preset",
+    "--expected-checkpoint-revision", "--limit-case", "--limit-treatment", "--limit-epoch", "--authorize-additional-invocation"
 ];
+const AGENT_CAMPAIGN_FLAGS = ["--agent-campaign", "--one-case", "--campaign-source-root", "--expected-checkpoint-revision", "--limit-case", "--limit-treatment", "--limit-epoch", "--authorize-additional-invocation"];
 export function assertAgentSuccessRateFlags(argv) {
     const flags = argv.filter((arg) => arg.startsWith("--"));
     const unsupported = [...new Set(flags.filter((flag) => !AGENT_SUCCESS_RATE_ALLOWED_FLAGS.includes(flag)))];
@@ -95,8 +110,11 @@ export function assertAgentSuccessRateFlags(argv) {
     }
 }
 export async function runExperimentRunCommandFromArgs(argv, options = {}) {
+    let parsed = false;
+    const campaignUsage = argv.includes("--agent-campaign") || argv.some(a => AGENT_CAMPAIGN_FLAGS.includes(a));
     try {
         const args = parseRunExperimentArgs(argv);
+        parsed = true;
         const context = options.context ?? createLabExecutionContext();
         const toolRoot = context.packageRoot;
         const registry = createDefaultExperimentPluginRegistry();
@@ -119,6 +137,8 @@ export async function runExperimentRunCommandFromArgs(argv, options = {}) {
             });
         }
         const inputs = await loadPluginInputs(args, toolRoot, context, outputRoot);
+        if (args.agentCampaign)
+            return await runAgentCampaignCommand(args, context, outputRoot, inputs, runId, options);
         const result = await runExperiment({
             pluginId: args.experimentId,
             registry,
@@ -219,16 +239,125 @@ export async function runExperimentRunCommandFromArgs(argv, options = {}) {
         return 0;
     }
     catch (error) {
-        if (process.env.DEBUG) {
+        if (campaignUsage) {
+            const sourceIndex = argv.indexOf("--campaign-source-root");
+            const source = sourceIndex >= 0 ? argv[sourceIndex + 1] : undefined;
+            const message = error instanceof Error ? error.message : "CAMPAIGN_FAILED";
+            console.error(boundMessage(message, [process.cwd(), options.context?.packageRoot ?? "", ...(source ? [path.resolve(options.context?.invocationCwd ?? process.cwd(), source)] : [])]));
+        }
+        else if (process.env.DEBUG) {
             console.error(error);
         }
         else {
             console.error(error instanceof Error ? error.message : String(error));
         }
-        return 1;
+        return campaignUsage && !parsed ? 2 : 1;
+    }
+}
+async function runAgentCampaignCommand(args, context, outputRoot, inputs, runId, options) {
+    const request = args.agentCampaign;
+    const sourceRoot = path.resolve(context.invocationCwd, request.sourceRoot ?? context.packageRoot);
+    try {
+        const packageName = "@dailephd/my-dev-kit-lab";
+        const validPackageVersion = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+        const executingMetadata = JSON.parse(await readFile(path.join(context.packageRoot, "package.json"), "utf8"));
+        if (executingMetadata.name !== packageName || typeof executingMetadata.version !== "string" || !validPackageVersion.test(executingMetadata.version))
+            throw new Error();
+        if (!(await lstat(path.join(sourceRoot, "src"))).isDirectory() || path.resolve(await realpath(sourceRoot)).toLowerCase() !== sourceRoot.toLowerCase())
+            throw new Error();
+        const metadata = JSON.parse(await readFile(path.join(sourceRoot, "package.json"), "utf8"));
+        if (metadata.name !== packageName || metadata.version !== executingMetadata.version)
+            throw new Error();
+    }
+    catch {
+        throw new Error("CAMPAIGN_SOURCE_UNVERIFIABLE: supply --campaign-source-root with a current my-dev-kit-lab source checkout; installed source bytes cannot be guessed.");
+    }
+    const boundary = { toolRoot: context.packageRoot, outputRoot };
+    await validateCampaignOutputPath(boundary, sourceRoot);
+    let entries = [];
+    try {
+        entries = await readdir(outputRoot);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        if (request.mode !== "new")
+            throw new Error("RESUMABLE_CAMPAIGN_REQUIRED: --out must contain an existing version 2 campaign.");
+    }
+    if (request.mode === "new" && entries.length > 0)
+        throw new Error("CAMPAIGN_OUTPUT_EXISTS: new requires an empty output root; existing artifacts are preserved.");
+    if (request.mode !== "new" && !entries.includes("campaign-checkpoints-v2"))
+        throw new Error("RESUMABLE_CAMPAIGN_REQUIRED: no version 2 checkpoint in --out.");
+    const validation = validateAgentSuccessRateConfig(args.config);
+    if (!validation.valid || !validation.config)
+        throw new Error("INVALID_CAMPAIGN_CONFIG");
+    const config = validation.config;
+    const tasks = selectAgentSuccessTasks(inputs.agentSuccessTasks, config);
+    const runtime = options.campaignRuntime;
+    const provider = config.agentId ? { kind: "real-agent", providerId: config.agentId, includeRealAgents: true, timeoutMs: config.timeoutMs ?? AGENT_SUCCESS_RATE_DEFAULT_AGENT_TIMEOUT_MS, repairAttempts: (config.repairAttempts ?? 0), kitCommand: config.kitCommand, contextDependencies: runtime?.contextDependencies, env: runtime?.env } : { kind: "deterministic-fixture" };
+    const preparation = { boundary, sourceRoot, corpusFile: resolvePackageResource(context, AGENT_SUCCESS_TASK_CATALOG_PATH), corpusRoot: context.packageRoot, tasks, treatments: AGENT_SUCCESS_RATE_TREATMENT_IDS, provider, dependencies: runtime?.dependencies };
+    // Source, corpus and canonical project byte checks precede even a task-free version probe.
+    let prepared = await prepareAgentSuccessCampaign(preparation);
+    if (provider.kind === "real-agent") {
+        provider.trustedExecutable = await observeProviderBuild(provider.providerId, { env: runtime?.env });
+        prepared = await prepareAgentSuccessCampaign(preparation);
+    }
+    let intent = request.mode === "new" ? { kind: "new-resumable" } : { kind: "resume" };
+    let reused = 0;
+    const previousEpochs = new Set();
+    if (request.mode !== "new") {
+        // Identity-scoped stores are not discovery: a different digest cannot create another campaign on resume.
+        const identities = await readdir(path.join(outputRoot, "campaign-checkpoints-v2"));
+        if (!identities.includes(prepared.identity.digest))
+            throw new Error("CAMPAIGN_IDENTITY_MISMATCH: current inputs do not match this output root.");
+        const stored = await readCampaignCheckpointV2(boundary, prepared.identity, tasks);
+        if (!stored.reusable || !stored.checkpoint || stored.identityVerification !== "MATCH")
+            throw new Error("RESUMABLE_CAMPAIGN_REQUIRED_MATCH");
+        const cp = stored.checkpoint;
+        cp.units.flatMap(u => u.epochs).forEach(e => previousEpochs.add(e.id));
+        reused = cp.units.filter(u => u.state === "completed").length;
+        if (request.mode === "continue-limit") {
+            const unit = cp.units.find(u => u.caseId === request.limitCase && u.treatmentId === request.limitTreatment);
+            if (cp.generation !== request.expectedRevision || !unit || unit.epochs.at(-1)?.id !== request.limitEpoch)
+                throw new Error("LIMIT_AUTHORIZATION_MISMATCH");
+            const authorization = { identityDigest: cp.identity.digest, generation: request.expectedRevision, revision: cp.integrity, caseId: request.limitCase, treatmentId: request.limitTreatment, acknowledgeInvocation: true, acknowledgeExternalLimit: true };
+            validateCampaignLimitAuthorization(authorization, cp, unit);
+            intent = { kind: "authorize-limit-continuation", authorization };
+        }
+    }
+    else {
+        await mkdir(outputRoot, { recursive: true });
+        await validateCampaignOutputPath(boundary, sourceRoot);
+        if ((await readdir(outputRoot)).length !== 0)
+            throw new Error("CAMPAIGN_OUTPUT_EXISTS");
     }
+    const result = await executeAgentSuccessCampaignV2(prepared, { intent, runId, limit: request.oneCase ? "one-case" : "all-selected-cases", hooks: runtime?.hooks });
+    const progressLines = [];
+    let progressFailed = false;
+    let progressValidated = false;
+    try {
+        const snapshot = await readCampaignProgress(boundary, prepared.identity, tasks);
+        progressValidated = true;
+        const progress = await writeAgentSuccessCampaignProgressReport({ snapshot, boundary });
+        progressLines.push(`Progress status: ${progress.model.state}`, `Progress checkpoint revision: ${progress.model.checkpointGeneration} (${progress.model.checkpointRevision})`, `Completed evaluations: ${progress.model.unitCounts.completed}/${progress.model.totalTreatmentUnits}`, `Completed cases: ${progress.model.caseCounts.completed}/${progress.model.selectedCaseCount}`, `Progress JSON: ${progress.outputPaths.jsonPath}`, `Progress Text: ${progress.outputPaths.textPath}`, `Progress HTML: ${progress.outputPaths.htmlPath}`);
+    }
+    catch {
+        progressFailed = true;
+        progressLines.push(progressValidated ? "Progress persistence: failed (validated checkpoint retained)." : "Progress status: blocked-integrity (checkpoint unavailable or untrusted).");
+        progressLines.push("Progress publication: failed; checkpoint/scientific execution outcome is reported separately.");
+    }
+    const newEpochs = result.checkpoint?.units.flatMap(u => u.epochs).filter(e => !previousEpochs.has(e.id)) ?? [];
+    // Provider evidence, never mere creation of a reservation, establishes invocation.
+    const newWork = newEpochs.some(e => e.terminal?.evidence.realAgent?.providerInvoked === true) ? "invoked" : newEpochs.some(e => e.phase === "invocation-authorized" || e.phase === "uncertain") ? "unconfirmed" : "none";
+    console.log(["Experiment: agent-success-rate", `Campaign mode: ${request.mode}`, `Identity: ${prepared.identity.digest.slice(0, 16)}`, `Status: ${result.status === "provider-limit" ? "paused-provider-limit" : result.status}`, `New provider work: ${newWork}`, `Validated work reused: ${reused > 0 ? "yes" : "no"}`, `Checkpoint revision: ${result.checkpoint?.generation ?? "unavailable"}`, `Final scientific artifacts: ${result.scientificArtifactsWritten ? "written" : "not written"}`, `Output: ${outputRoot}`, ...result.errors.map(e => `Failure: ${e}`)].join("\n"));
+    console.log(progressLines.join("\n"));
+    return !progressFailed && ["completed", "already-complete", "partial"].includes(result.status) ? 0 : 1;
 }
 export function parseRunExperimentArgs(argv) {
+    let agentCampaignMode;
+    let oneCase = false, authorize = false;
+    let campaignSourceRoot, limitCase, limitTreatment, limitEpoch, timeoutPreset;
+    let expectedRevision;
     let experimentId = "";
     let targetPath;
     let outDir;
@@ -259,9 +388,41 @@ export function parseRunExperimentArgs(argv) {
         assertAgentSuccessRateFlags(argv);
     for (let index = 0; index < argv.length; index += 1) {
         const arg = argv[index];
+        if (arg !== undefined && arg.startsWith("--") && seenFlags.includes(arg) && (AGENT_CAMPAIGN_FLAGS.includes(arg) || arg === "--timeout-preset" || (argv.includes("agent-success-rate") && arg !== "--case" && arg !== "--benchmark-project")))
+            throw new Error(`${arg} may be supplied only once.`);
         if (arg !== undefined && arg.startsWith("--"))
             seenFlags.push(arg);
-        if (arg === "--experiment") {
+        if (arg === "--agent-campaign") {
+            agentCampaignMode = readRequiredValue(argv, ++index, arg);
+        }
+        else if (arg === "--one-case") {
+            oneCase = true;
+        }
+        else if (arg === "--authorize-additional-invocation") {
+            authorize = true;
+        }
+        else if (arg === "--campaign-source-root") {
+            campaignSourceRoot = readRequiredValue(argv, ++index, arg);
+        }
+        else if (arg === "--expected-checkpoint-revision") {
+            const value = readRequiredValue(argv, ++index, arg);
+            if (!/^[1-9]\d*$/.test(value))
+                throw new Error("--expected-checkpoint-revision must be a positive integer.");
+            expectedRevision = parsePositiveInteger(arg, value);
+        }
+        else if (arg === "--limit-case") {
+            limitCase = readRequiredValue(argv, ++index, arg);
+        }
+        else if (arg === "--limit-treatment") {
+            limitTreatment = readRequiredValue(argv, ++index, arg);
+        }
+        else if (arg === "--limit-epoch") {
+            limitEpoch = readRequiredValue(argv, ++index, arg);
+        }
+        else if (arg === "--timeout-preset") {
+            timeoutPreset = readRequiredValue(argv, ++index, arg);
+        }
+        else if (arg === "--experiment") {
             experimentId = readRequiredValue(argv, ++index, "--experiment");
         }
         else if (arg === "--target") {
@@ -353,6 +514,31 @@ export function parseRunExperimentArgs(argv) {
     if (!experimentId) {
         throw new Error("Usage: --experiment <id> [--target <path>] [--out <directory>]");
     }
+    const campaignFlagsPresent = seenFlags.some(f => AGENT_CAMPAIGN_FLAGS.includes(f));
+    if ((campaignFlagsPresent || timeoutPreset !== undefined) && experimentId !== agentSuccessRatePlugin.metadata.id)
+        throw new Error("Agent campaign and timeout preset flags are only supported for --experiment agent-success-rate.");
+    if (campaignFlagsPresent && agentCampaignMode === undefined)
+        throw new Error("Campaign flags require --agent-campaign <new|resume|continue-limit>.");
+    if (agentCampaignMode !== undefined && !["new", "resume", "continue-limit"].includes(agentCampaignMode))
+        throw new Error("--agent-campaign must be new, resume or continue-limit.");
+    if (agentCampaignMode !== undefined && !outDir?.trim())
+        throw new Error("--agent-campaign requires a stable --out directory.");
+    const limitPresent = expectedRevision !== undefined || limitCase !== undefined || limitTreatment !== undefined || limitEpoch !== undefined || authorize;
+    if (agentCampaignMode !== "continue-limit" && limitPresent)
+        throw new Error("Limit authorization flags require --agent-campaign continue-limit.");
+    if (agentCampaignMode === "continue-limit") {
+        if (expectedRevision === undefined || !limitCase || !limitTreatment || !limitEpoch || !authorize)
+            throw new Error("continue-limit requires --expected-checkpoint-revision, --limit-case, --limit-treatment, --limit-epoch and --authorize-additional-invocation.");
+        if (expectedRevision > 1000000 || !campaignIdentifier(limitCase) || !["raw-full-file", "context-pack"].includes(limitTreatment) || !/^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/.test(limitEpoch))
+            throw new Error("Invalid limit revision, case, treatment or epoch identifier.");
+    }
+    if (timeoutPreset !== undefined) {
+        if (timeoutMs !== undefined)
+            throw new Error("--timeout-preset and --timeout-ms cannot be combined.");
+        if (agentFlagValues.length !== 1 || includeRealAgents !== true || !["codex", "claude"].includes(agentFlagValues[0]))
+            throw new Error("--timeout-preset requires --agent <codex|claude> and --include-real-agents.");
+        timeoutMs = resolveAgentTimeoutPreset(agentFlagValues[0], timeoutPreset);
+    }
     const KIT_COMMAND_PLUGIN_IDS = [
         warmIndexReusePlugin.metadata.id,
         incrementalChangeStalenessPlugin.metadata.id,
@@ -540,6 +726,7 @@ export function parseRunExperimentArgs(argv) {
     }
     return {
         experimentId,
+        ...(agentCampaignMode ? { agentCampaign: { mode: agentCampaignMode, oneCase, sourceRoot: campaignSourceRoot, expectedRevision, limitCase, limitTreatment: limitTreatment, limitEpoch, authorize } } : {}),
         targetPath,
         outDir,
         syntheticConfigPath,

package/dist/src/core/runMeasuredCommand.js

@@ -56,6 +56,7 @@ export async function runMeasuredCommand(options) {
                 cwd: options.cwd,
                 env: childEnv,
                 shell: false,
+                windowsHide: true,
                 stdio: options.stdinText !== undefined ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
                 // Own process group so a bounded termination can reach descendants. Windows reaches the tree
                 // through `taskkill /T`, and `detached` there would open a new console, so it is not set.
@@ -123,6 +124,9 @@ export async function runMeasuredCommand(options) {
             // without asserting a limit of our own.
             if (error.code === "ENOENT" && existsSync(options.cwd)) {
                 spawnError += ` (the working directory exists but the process could not be started in it; cwd length ${options.cwd.length} characters)`;
+                if (process.platform === "win32") {
+                    spawnError += "; use a shorter output/sandbox path on this Windows host";
+                }
             }
         });
         // A failed spawn can also make the OS report the never-connected stdout/stderr pipes as errors (Windows:

package/dist/src/evaluation/benchmarkSandbox/gitExecutor.js

@@ -31,7 +31,9 @@ export async function runSandboxGit(target, args, options = {}) {
     const result = await runMeasuredCommand({
         commandId,
         executable: "git",
-        args: ["-c", "core.quotepath=false", "-c", "core.autocrlf=false", "-c", "core.fsmonitor=false", ...args],
+        // Initialization creates .git paths before repository-local configuration exists.
+        // Keep long-path support command-local so even that first invocation is covered.
+        args: ["-c", "core.quotepath=false", "-c", "core.autocrlf=false", "-c", "core.longpaths=true", "-c", "core.fsmonitor=false", ...args],
         cwd: target.projectRoot,
         outDir: path.join(target.evidenceRoot, "git"),
         env,

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

@@ -0,0 +1,216 @@
+import { agentSuccessPatchArtifactPath } from "./execution.js";
+import { agentSuccessContextArtifactPath, agentSuccessAgentArtifactDirectory } from "./realAgentExecution.js";
+import { classifyAgentSuccessAttempt } from "./repairPolicy.js";
+import { analyzeAgentSuccessTreatment } from "./analysis.js";
+import { campaignAssert, campaignExact, campaignHash, campaignIdentifier, canonicalCampaignJson, isCampaignDigest, validateCampaignIdentity } from "./campaignIdentity.js";
+export const CAMPAIGN_CHECKPOINT_SCHEMA = "my-dev-kit-lab-agent-success-rate-campaign-checkpoint-v1";
+export const CAMPAIGN_CHECKPOINT_MAX_BYTES = 16 * 1024 * 1024;
+const nullable = (rule) => (v) => { if (v !== null)
+    rule(v); };
+const nil = (v) => campaignAssert(v === null);
+const bool = (v) => campaignAssert(typeof v === "boolean");
+const number = (v) => campaignAssert(typeof v === "number" && Number.isFinite(v) && v >= 0);
+const integer = (v) => { number(v); campaignAssert(Number.isSafeInteger(v)); };
+const identifier = (v) => campaignAssert(campaignIdentifier(v));
+const digest = (v) => campaignAssert(isCampaignDigest(v));
+const one = (...values) => (v) => campaignAssert(values.includes(v));
+const list = (rule, max = 2000) => (v) => { campaignAssert(Array.isArray(v) && v.length <= max, "DATA_BOUND"); v.forEach(rule); };
+const shape = (rules, optional = {}) => (v) => {
+    campaignAssert(typeof v === "object" && v !== null && !Array.isArray(v));
+    const row = v;
+    campaignAssert(Object.keys(row).every((k) => Object.hasOwn(rules, k) || Object.hasOwn(optional, k)));
+    for (const [k, r] of Object.entries(rules))
+        r(row[k]);
+    for (const [k, r] of Object.entries(optional))
+        if (Object.hasOwn(row, k))
+            r(row[k]);
+};
+const timestamp = (v) => campaignAssert(typeof v === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(v) && Number.isFinite(Date.parse(v)) && new Date(v).toISOString() === v);
+export function validateCampaignRelativePath(v) {
+    campaignAssert(typeof v === "string" && v.length > 0 && v.length <= 512 && /^[A-Za-z0-9._/-]+$/.test(v) && !v.startsWith("/") && v.split("/").every((p) => p !== "" && p !== "." && p !== ".." && !p.endsWith(".") && !/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(p)), "UNSAFE_PATH");
+}
+const rel = validateCampaignRelativePath;
+const cleanup = shape({ attempted: bool, removed: bool, reason: nil });
+const check = shape({ checkId: identifier, class: one("task", "regression"), status: one("passed", "failed", "timeout", "error"), exitCode: nullable((v) => campaignAssert(typeof v === "number" && Number.isSafeInteger(v))), durationMs: number, failureReason: nil });
+const verification = shape({ phase: one("baseline", "post-edit"), taskResults: list(check), regressionResults: list(check) });
+const assessment = shape({ evaluable: bool, reasons: list(one("NO_CHECKS", "ALL_TASK_CHECKS_PASSED", "REGRESSION_CHECK_FAILED", "CHECK_NOT_EVALUABLE"), 4) });
+const token = shape({ totalTokens: nullable(integer), inputTokens: nullable(integer), outputTokens: nullable(integer), source: one("provider-reported", "agent-reported", "cli-json", "otel", "estimated-from-text", "unavailable"), reliability: one("high", "medium", "low", "unavailable") });
+const providerStatus = one("not-invoked", "completed", "failed", "skipped", "timeout", "agent-unavailable", "agent-limit-reached", "invalid-output");
+const failure = one("none", "patch-malformed", "patch-policy-rejected", "patch-check-failed", "patch-apply-failed", "task-check-failed", "regression-failed", "required-behavior-unsatisfied", "baseline-invalid", "context-unavailable", "provider-unavailable", "provider-limit-reached", "provider-timeout", "provider-failed", "provider-empty-answer", "provider-not-invoked", "infrastructure-failure", "cleanup-failed", "integrity-unproven", "integrity-mutated", "evidence-incomplete");
+const feedback = shape({ basedOnAttempt: one(1, 2, 3), category: failure, patchProduced: bool, patchApplied: bool, taskChecks: one("all-passed", "some-failed", "not-evaluated"), regressionChecks: one("all-passed", "some-failed", "not-evaluated"), requiredBehavior: one("verified", "not-verified", "not-evaluated"), failedTaskCheckCount: nullable(integer), failedRegressionCheckCount: nullable(integer), previousPatchIncluded: bool, previousPatchTruncated: bool });
+const realAgent = shape({ providerId: one("codex", "claude"), attempt: one(1, 2, 3), promptTransport: one("stdin"), providerInvoked: bool, providerStatus, providerStatusReason: nil, finalAnswerAvailable: bool, promptChars: nullable(integer), context: shape({ contextMode: one("raw-full-file", "context-pack"), availability: one("available", "partial", "unavailable"), reason: nil, selectionPolicyId: identifier, myDevKitVersion: nullable(identifier), includedSourceFiles: list(rel), contextChars: integer, estimatedContextTokens: integer, contextArtifactPath: nullable(rel) }), agentArtifactDirectory: nullable(rel), agentArtifacts: shape({ prompt: nullable(rel), result: nullable(rel), stdout: nullable(rel), stderr: nullable(rel), telemetry: nullable(rel) }), cwdCleanup: cleanup }, { repairFeedback: nullable(feedback) });
+const fileStatus = one("added", "modified", "deleted");
+const patch = shape({ attempted: bool, outcome: nullable(one("parse-failure", "policy-rejection", "git-check-failure", "git-apply-failure", "success")), code: nullable(identifier), message: nil, appliedFiles: list(shape({ path: rel, status: fileStatus })), rejections: list(shape({ code: identifier, path: nullable(rel) }), 20), attemptedProtectedPaths: list(rel), proposedPatchBytes: integer });
+const change = shape({ baselineCommit: identifier, changedFiles: list(shape({ relativePath: rel, status: fileStatus, beforeSha256: nullable(digest), afterSha256: nullable(digest), additions: nullable(integer), deletions: nullable(integer) })), addedCount: integer, modifiedCount: integer, deletedCount: integer, changedCount: integer, totalAdditions: integer, totalDeletions: integer });
+const baseRules = { treatmentId: one("raw-full-file", "context-pack"), status: one("completed", "partial", "failed", "skipped"), availability: one("complete", "baseline-invalid", "incomplete", "infrastructure-failure"), sandboxId: identifier, sandboxBaseline: nullable(shape({ commit: identifier, fileCount: integer, digest })), baselineTextLineCount: nullable(integer), baselineVerification: nullable(verification), baselineAssessment: nullable(assessment), patch, change: nullable(change), postEditVerification: nullable(verification), protectedIntegrity: shape({ status: one("intact", "mutated", "unproven"), mutatedPaths: list(rel) }), timing: shape({ agentDurationMs: nullable(number), baselineVerificationDurationMs: nullable(number), patchPipelineDurationMs: nullable(number), postEditVerificationDurationMs: nullable(number), evaluationDurationMs: nullable(number) }), agentTokenUsage: nullable(token), cleanup, proposedPatchPath: nullable(rel), appliedPatchPath: nullable(rel), errors: list(shape({ code: identifier, message: one("details-omitted") }), 100) };
+const singleEvidence = shape(baseRules, { realAgent });
+const attempt = shape({ attemptNumber: one(1, 2, 3), providerId: one("codex", "claude"), providerStatus, startedAt: timestamp, completedAt: timestamp, durationMs: nullable(number), tokenUsage: nullable(token), proposedPatchAvailability: one("available", "unavailable"), patchApplicationOutcome: one("parse-failure", "policy-rejection", "git-check-failure", "git-apply-failure", "success", "not-attempted"), baselineAssessment: nullable(assessment), postEditVerification: nullable(verification), changeEvidenceAvailability: one("available", "unavailable"), taskSuccess: nullable(bool), failureCategory: failure, repairEligible: bool, cleanupResult: cleanup, evidence: singleEvidence });
+const treatment = shape(baseRules, { realAgent, attempts: list(attempt, 3) });
+/** Discard free-form explanations only; unknown fields still fail the closed decoder. Original evidence is never mutated. */
+export function projectCampaignTreatmentEvidence(source) {
+    canonicalCampaignJson(source);
+    const walk = (v) => Array.isArray(v) ? v.map(walk) : v !== null && typeof v === "object" ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, k === "message" && Object.keys(v).length === 2 && Object.hasOwn(v, "code") ? "details-omitted" : ["message", "reason", "failureReason", "providerStatusReason"].includes(k) ? null : walk(x)])) : v;
+    const result = walk(source);
+    treatment(result);
+    return result;
+}
+export function requiredCampaignArtifacts(e, task, allowUnfinished = false) {
+    const refs = new Map();
+    const attempts = e.attempts?.map((a) => a.evidence) ?? [e];
+    for (let i = 0; i < attempts.length; i++) {
+        const a = attempts[i];
+        for (const kind of ["proposed", "applied"]) {
+            const p = kind === "proposed" ? a.proposedPatchPath : a.appliedPatchPath;
+            if (p !== null) {
+                campaignAssert(p === agentSuccessPatchArtifactPath(task.benchmarkProject, task.id, a.treatmentId, kind, (i + 1)));
+                campaignAssert(!refs.has(p));
+                refs.set(p, "patch");
+            }
+        }
+        const real = a.realAgent;
+        if (real) {
+            const context = real.context.contextArtifactPath;
+            if (context !== null || !allowUnfinished) {
+                campaignAssert(context === agentSuccessContextArtifactPath(task.benchmarkProject, task.id, a.treatmentId));
+                refs.set(context, "context");
+            }
+            if (real.agentArtifactDirectory !== null || !allowUnfinished)
+                campaignAssert(real.agentArtifactDirectory === agentSuccessAgentArtifactDirectory(task.benchmarkProject, task.id, a.treatmentId, (i + 1)));
+            else
+                campaignAssert(!real.providerInvoked && Object.values(real.agentArtifacts).every(p => p === null), "MISSING_PROVIDER_REFERENCES");
+            for (const [key, p] of Object.entries(real.agentArtifacts))
+                if (p !== null) {
+                    campaignAssert(real.agentArtifactDirectory !== null && p.startsWith(`${real.agentArtifactDirectory}/`) && !p.slice(real.agentArtifactDirectory.length + 1).includes("/") && /\.(json|txt|log)$/.test(p), "UNSAFE_PROVIDER_ARTIFACT");
+                    campaignAssert(key !== "prompt" || p.endsWith(".txt"));
+                    campaignAssert(!refs.has(p));
+                    refs.set(p, "provider");
+                }
+        }
+    }
+    return [...refs].map(([path, kind]) => ({ path, kind })).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+export function validateCampaignCompletion(value, identity, task, treatmentId) {
+    validateCampaignIdentity(identity);
+    campaignAssert(identity.selected.some((s) => s.caseId === task.id && s.projectId === task.benchmarkProject && s.taskDigest === campaignHash(canonicalCampaignJson(task))), "TASK_IDENTITY_MISMATCH");
+    campaignExact(value, ["sourceSchema", "evidence", "taskSuccess", "artifacts"]);
+    campaignAssert(value.sourceSchema === "my-dev-kit-lab-agent-success-rate-execution-v1");
+    bool(value.taskSuccess);
+    treatment(value.evidence);
+    const e = value.evidence;
+    const rows = e.attempts?.map((a) => a.evidence) ?? [e];
+    campaignAssert(rows.length > 0 && rows.length <= 1 + identity.config.repairAttempts);
+    for (let i = 0; i < rows.length; i++) {
+        const a = rows[i];
+        campaignAssert(a.treatmentId === treatmentId && a.status === "completed" && a.availability === "complete" && a.cleanup.attempted && a.cleanup.removed && a.protectedIntegrity.status !== "unproven" && a.sandboxBaseline !== null && a.baselineAssessment?.evaluable === true && a.baselineAssessment.reasons.length === 0 && a.patch.attempted && a.patch.outcome !== null && a.proposedPatchPath !== null && a.baselineVerification !== null, "INCOMPLETE_EVIDENCE");
+        campaignAssert(a.protectedIntegrity.status !== "intact" || a.protectedIntegrity.mutatedPaths.length === 0);
+        campaignAssert(a.protectedIntegrity.status !== "mutated" || a.protectedIntegrity.mutatedPaths.length > 0);
+        campaignAssert(a.protectedIntegrity.mutatedPaths.every((p) => task.protectedFiles.includes(p)), "PROTECTED_PROOF_MISMATCH");
+        campaignAssert(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(a.sandboxBaseline.commit) && a.sandboxBaseline.fileCount > 0, "BASELINE_PROOF_MISMATCH");
+        if (a.change !== null) {
+            const changes = a.change;
+            campaignAssert(changes.baselineCommit === a.sandboxBaseline.commit && changes.changedCount === changes.changedFiles.length && new Set(changes.changedFiles.map((f) => f.relativePath)).size === changes.changedFiles.length, "CHANGE_SUMMARY_MISMATCH");
+            for (const [status, count] of [["added", changes.addedCount], ["modified", changes.modifiedCount], ["deleted", changes.deletedCount]])
+                campaignAssert(count === changes.changedFiles.filter((f) => f.status === status).length, "CHANGE_SUMMARY_MISMATCH");
+            campaignAssert(changes.totalAdditions === changes.changedFiles.reduce((sum, f) => sum + (f.additions ?? 0), 0) && changes.totalDeletions === changes.changedFiles.reduce((sum, f) => sum + (f.deletions ?? 0), 0), "CHANGE_SUMMARY_MISMATCH");
+            campaignAssert(changes.changedFiles.every((f) => f.status === "added" ? f.beforeSha256 === null && f.afterSha256 !== null : f.status === "deleted" ? f.beforeSha256 !== null && f.afterSha256 === null : f.beforeSha256 !== null && f.afterSha256 !== null), "CHANGE_DIGEST_MISMATCH");
+        }
+        campaignAssert((a.appliedPatchPath !== null) === (a.patch.outcome === "success"));
+        campaignAssert(a.patch.outcome === "success" ? a.change !== null && a.postEditVerification !== null : a.change === null && a.postEditVerification === null);
+        for (const [phase, v] of [["baseline", a.baselineVerification], ["post-edit", a.postEditVerification]]) {
+            if (v === null)
+                continue;
+            campaignAssert(v.phase === phase);
+            for (const [checkClass, definitions, results] of [["task", task.taskChecks, v.taskResults], ["regression", task.regressionChecks, v.regressionResults]]) {
+                campaignAssert(results.length === definitions.length && results.every((r, j) => r.checkId === definitions[j].id && r.class === checkClass && ["passed", "failed"].includes(r.status) && (r.status === "passed" ? r.exitCode === 0 : r.exitCode !== null && r.exitCode !== 0)), "VERIFICATION_MISSING");
+            }
+        }
+        campaignAssert(a.baselineVerification.taskResults.some((r) => r.status === "failed") && a.baselineVerification.regressionResults.every((r) => r.status === "passed"));
+        if (identity.config.providerId === "deterministic-fixture")
+            campaignAssert(a.realAgent === undefined && a.agentTokenUsage === null && a.timing.agentDurationMs === null);
+        else {
+            const r = a.realAgent;
+            campaignAssert(r && r.providerId === identity.config.providerId && r.attempt === i + 1 && r.providerInvoked && r.providerStatus === "completed" && r.finalAnswerAvailable && r.cwdCleanup.attempted && r.cwdCleanup.removed && r.context.contextMode === treatmentId && r.context.availability !== "unavailable" && r.agentArtifacts.prompt !== null && r.agentArtifacts.result !== null);
+        }
+        const record = e.attempts?.[i];
+        if (a.realAgent?.repairFeedback !== undefined && a.realAgent.repairFeedback !== null)
+            campaignAssert(i > 0 && a.realAgent.repairFeedback.basedOnAttempt === i && a.realAgent.repairFeedback.category === e.attempts[i - 1].failureCategory, "REPAIR_FEEDBACK_MISMATCH");
+        if (record) {
+            const classification = classifyAgentSuccessAttempt(a, analyzeAgentSuccessTreatment(task, a).metrics);
+            campaignAssert(record.failureCategory === classification.category && record.repairEligible === classification.repairEligible && record.taskSuccess === classification.taskSuccess && record.durationMs === a.timing.agentDurationMs && canonicalCampaignJson(record.tokenUsage) === canonicalCampaignJson(a.agentTokenUsage) && record.proposedPatchAvailability === (a.proposedPatchPath === null ? "unavailable" : "available") && record.patchApplicationOutcome === (a.patch.outcome ?? "not-attempted") && canonicalCampaignJson(record.baselineAssessment) === canonicalCampaignJson(a.baselineAssessment) && canonicalCampaignJson(record.postEditVerification) === canonicalCampaignJson(a.postEditVerification) && record.changeEvidenceAvailability === (a.change === null ? "unavailable" : "available"));
+            campaignAssert(record.attemptNumber === i + 1 && record.providerId === identity.config.providerId && record.providerStatus === a.realAgent?.providerStatus && record.taskSuccess === (analyzeAgentSuccessTreatment(task, a).metrics.taskSuccess.value === true) && canonicalCampaignJson(record.cleanupResult) === canonicalCampaignJson(a.cleanup) && record.completedAt >= record.startedAt);
+            if (i > 0)
+                campaignAssert(e.attempts[i - 1].repairEligible && e.attempts[i - 1].taskSuccess === false);
+        }
+    }
+    campaignAssert(new Set(rows.map((r) => r.sandboxId)).size === rows.length);
+    if (e.attempts) {
+        const { attempts: _attempts, ...final } = e;
+        campaignAssert(canonicalCampaignJson(final) === canonicalCampaignJson(rows[rows.length - 1]));
+    }
+    campaignAssert(value.taskSuccess === (analyzeAgentSuccessTreatment(task, e).metrics.taskSuccess.value === true));
+    const expected = requiredCampaignArtifacts(e, task);
+    list(shape({ path: rel, kind: one("patch", "context", "provider"), sha256: digest, bytes: integer }), 32)(value.artifacts);
+    const artifacts = value.artifacts;
+    campaignAssert(canonicalCampaignJson(artifacts.map(({ path, kind }) => ({ path, kind }))) === canonicalCampaignJson(expected), "ARTIFACT_REFERENCE_MISMATCH");
+}
+export function sealCampaignCheckpoint(body) { return { ...body, integrity: campaignHash(canonicalCampaignJson(body)) }; }
+export function validateCampaignCheckpoint(value, tasks) {
+    campaignAssert(Buffer.byteLength(canonicalCampaignJson(value)) <= CAMPAIGN_CHECKPOINT_MAX_BYTES, "DATA_BOUND");
+    campaignExact(value, ["schemaVersion", "identity", "generation", "parentIntegrity", "createdAt", "updatedAt", "units", "integrity"]);
+    campaignAssert(value.schemaVersion === CAMPAIGN_CHECKPOINT_SCHEMA, "UNSUPPORTED_SCHEMA");
+    validateCampaignIdentity(value.identity);
+    integer(value.generation);
+    campaignAssert(Number(value.generation) >= 1 && Number(value.generation) <= 1_000_000);
+    nullable(digest)(value.parentIntegrity);
+    timestamp(value.createdAt);
+    timestamp(value.updatedAt);
+    campaignAssert(String(value.updatedAt) >= String(value.createdAt));
+    const identity = value.identity;
+    campaignAssert(tasks.length === identity.selected.length && tasks.every((t, i) => t.id === identity.selected[i].caseId && t.benchmarkProject === identity.selected[i].projectId && campaignHash(canonicalCampaignJson(t)) === identity.selected[i].taskDigest), "TASK_IDENTITY_MISMATCH");
+    campaignAssert(Array.isArray(value.units) && value.units.length === tasks.length * 2);
+    for (let i = 0; i < value.units.length; i++) {
+        const u = value.units[i];
+        campaignExact(u, ["caseId", "treatmentId", "state", "errorCode", "completion"]);
+        const task = tasks[Math.floor(i / 2)];
+        campaignAssert(u.caseId === task.id && u.treatmentId === value.identity.treatmentOrder[i % 2]);
+        one("pending", "in-progress", "completed", "incomplete", "paused-limit")(u.state);
+        nullable(one("INTERRUPTED", "INVALID_EVIDENCE", "PROVIDER_LIMIT"))(u.errorCode);
+        if (u.state === "completed") {
+            campaignAssert(u.errorCode === null);
+            validateCampaignCompletion(u.completion, value.identity, task, String(u.treatmentId));
+        }
+        else {
+            campaignAssert(u.completion === null);
+            campaignAssert(u.state === "paused-limit" ? u.errorCode === "PROVIDER_LIMIT" : u.state === "incomplete" ? ["INTERRUPTED", "INVALID_EVIDENCE"].includes(String(u.errorCode)) : u.errorCode === null);
+        }
+    }
+    const { integrity, ...body } = value;
+    campaignAssert(isCampaignDigest(integrity) && integrity === campaignHash(canonicalCampaignJson(body)), "CHECKPOINT_INTEGRITY");
+}
+export function createCampaignCheckpoint(identity, tasks, at) {
+    const result = sealCampaignCheckpoint({ schemaVersion: CAMPAIGN_CHECKPOINT_SCHEMA, identity: structuredClone(identity), generation: 1, parentIntegrity: null, createdAt: at, updatedAt: at, units: identity.selected.flatMap((s) => identity.treatmentOrder.map((treatmentId) => ({ caseId: s.caseId, treatmentId, state: "pending", errorCode: null, completion: null }))) });
+    validateCampaignCheckpoint(result, tasks);
+    return result;
+}
+export function transitionCampaignCheckpoint(previous, tasks, index, next, at, completion = null, classifiedProviderOutcome = null) {
+    validateCampaignCheckpoint(previous, tasks);
+    campaignAssert(Number.isSafeInteger(index) && index >= 0 && index < previous.units.length);
+    campaignAssert(next !== "paused-limit" || (classifiedProviderOutcome === "agent-limit-reached" && previous.identity.config.providerId !== "deterministic-fixture"), "LIMIT_CLASSIFICATION_REQUIRED");
+    const state = previous.units[index].state;
+    campaignAssert(state === "pending" ? next === "in-progress" : state === "in-progress" && ["completed", "incomplete", "paused-limit"].includes(next), "INVALID_TRANSITION");
+    const { integrity, ...body } = structuredClone(previous);
+    body.generation++;
+    body.parentIntegrity = integrity;
+    body.updatedAt = at;
+    body.units[index] = { ...body.units[index], state: next, errorCode: next === "incomplete" ? "INTERRUPTED" : next === "paused-limit" ? "PROVIDER_LIMIT" : null, completion };
+    const result = sealCampaignCheckpoint(body);
+    validateCampaignCheckpoint(result, tasks);
+    return result;
+}
+export function validateCampaignHistory(previous, next) {
+    campaignAssert(previous.identity.digest === next.identity.digest && next.generation === previous.generation + 1 && next.parentIntegrity === previous.integrity && next.createdAt === previous.createdAt && next.updatedAt >= previous.updatedAt, "INVALID_HISTORY");
+    let changes = 0;
+    previous.units.forEach((u, i) => { const v = next.units[i]; if (canonicalCampaignJson(u) === canonicalCampaignJson(v))
+        return; changes++; campaignAssert(u.caseId === v.caseId && u.treatmentId === v.treatmentId && (u.state === "pending" ? v.state === "in-progress" : u.state === "in-progress" && ["completed", "incomplete", "paused-limit"].includes(v.state)), "INVALID_HISTORY"); });
+    campaignAssert(changes === 1, "INVALID_HISTORY");
+}