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

package/dist/src/core/runMeasuredCommand.js

@@ -1,8 +1,9 @@
+import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { parseCommandString, serializeCommand } from "./commandLine.js";
-import { forceTerminateProcess } from "./processTree.js";
+import { forceTerminateProcess, terminateProcessTree } from "./processTree.js";
 import { buildResolvedCommandInvocation, resolveCommandInvocation } from "./resolveCommand.js";
 export { parseCommandString } from "./commandLine.js";
 export async function runMeasuredCommand(options) {
@@ -10,6 +11,11 @@ export async function runMeasuredCommand(options) {
     const named = readCommandName(options);
     const commandString = named.commandString;
     const trailingArgs = [...named.args, ...(options.extraArgs ?? [])];
+    const bounded = options.stdoutMaxBytes !== undefined ||
+        options.stderrMaxBytes !== undefined ||
+        options.inheritParentEnv === false ||
+        options.terminateProcessTree === true;
+    const childEnv = options.inheritParentEnv === false ? { ...options.env } : { ...process.env, ...options.env };
     // Windows .cmd/.bat/.ps1 argument assembly is owned by resolveCommand.ts so
     // that every spawn site (measured commands and managed long-running processes)
     // shares exactly one shim rule.
@@ -24,7 +30,7 @@ export async function runMeasuredCommand(options) {
         }, trailingArgs)
         : resolveCommandInvocation(named.executable, trailingArgs, {
             cwd: options.cwd,
-            env: { ...process.env, ...options.env },
+            env: childEnv,
             allowPowerShellShim: options.allowPowerShellShim
         });
     const resolution = invocation.resolvedCommand;
@@ -36,8 +42,9 @@ export async function runMeasuredCommand(options) {
     const startedAt = new Date().toISOString();
     const started = Date.now();
     const result = await new Promise((resolve) => {
-        let stdout = "";
-        let stderr = "";
+        const stdoutCollector = new OutputCollector(options.stdoutMaxBytes);
+        const stderrCollector = new OutputCollector(options.stderrMaxBytes);
+        let outputLimit;
         let spawnError;
         let timedOut = false;
         let timeout;
@@ -47,9 +54,12 @@ export async function runMeasuredCommand(options) {
         try {
             child = spawn(executable, args, {
                 cwd: options.cwd,
-                env: { ...process.env, ...options.env },
+                env: childEnv,
                 shell: false,
-                stdio: options.stdinText !== undefined ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"]
+                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.
+                ...(options.terminateProcessTree === true && process.platform !== "win32" ? { detached: true } : {})
             });
         }
         catch (error) {
@@ -66,8 +76,8 @@ export async function runMeasuredCommand(options) {
                 endedAt,
                 durationMs,
                 exitCode: null,
-                stdout,
-                stderr,
+                stdout: "",
+                stderr: "",
                 stdoutPath,
                 stderrPath,
                 telemetryPath,
@@ -76,22 +86,53 @@ export async function runMeasuredCommand(options) {
                 resolvedCommand: resolution
             };
             void Promise.all([
-                writeArtifact(stdoutPath, stdout),
-                writeArtifact(stderrPath, stderr),
+                writeArtifact(stdoutPath, ""),
+                writeArtifact(stderrPath, ""),
                 writeArtifact(telemetryPath, JSON.stringify(measured, null, 2))
             ]).then(() => resolve(measured));
             return;
         }
         // stdout/stderr are always piped in both stdio branches above.
-        child.stdout.on("data", (chunk) => {
-            stdout += String(chunk);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += String(chunk);
-        });
+        // The process-termination step is shared by the timeout and the opt-in output limit. Bounded callers
+        // get an awaited tree termination; everyone else keeps the legacy fire-and-forget single termination.
+        const KILL_GRACE_MS = 3000;
+        const terminate = () => {
+            if (options.terminateProcessTree === true) {
+                void terminateProcessTree(child.pid);
+            }
+            else {
+                forceTerminateProcess(child.pid);
+            }
+            killGraceTimeout ??= setTimeout(() => {
+                void settle(null);
+            }, KILL_GRACE_MS);
+        };
+        const collect = (collector, stream, limit) => (chunk) => {
+            if (collector.push(chunk) && limit !== undefined && outputLimit === undefined) {
+                outputLimit = { stream, limitBytes: limit };
+                spawnError = `Command ${stream} exceeded ${limit} bytes.`;
+                terminate();
+            }
+        };
+        child.stdout.on("data", collect(stdoutCollector, "stdout", options.stdoutMaxBytes));
+        child.stderr.on("data", collect(stderrCollector, "stderr", options.stderrMaxBytes));
         child.on("error", (error) => {
             spawnError = error.message;
+            // A failed spawn in a working directory that exists is not a missing executable; the OS may be refusing the path (for
+            // example a very long cwd on Windows). Report the measured length
+            // 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)`;
+            }
         });
+        // A failed spawn can also make the OS report the never-connected stdout/stderr pipes as errors (Windows:
+        // read ENOTCONN). They are stream events of this one failed process: record the first cause once and let
+        // the 'close' event settle the result, instead of letting an unhandled 'error' event end the whole process.
+        const recordStreamError = (stream) => (error) => {
+            spawnError = spawnError ?? `Failed to read command ${stream}: ${error.message}`;
+        };
+        child.stdout.on("error", recordStreamError("stdout"));
+        child.stderr.on("error", recordStreamError("stderr"));
         if (options.stdinText !== undefined) {
             // A child that exits or closes stdin before we write must not crash the process (EPIPE).
             child.stdin?.on("error", (error) => {
@@ -106,7 +147,7 @@ export async function runMeasuredCommand(options) {
         // 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.
-        const KILL_GRACE_MS = 3000;
+        // (KILL_GRACE_MS and the shared `terminate` step are declared above, beside the output collectors.)
         const settle = async (exitCode) => {
             if (settled)
                 return;
@@ -128,6 +169,8 @@ export async function runMeasuredCommand(options) {
             child.unref();
             const endedAt = new Date().toISOString();
             const durationMs = Date.now() - started;
+            const stdout = stdoutCollector.toString();
+            const stderr = stderrCollector.toString();
             await writeArtifact(stdoutPath, stdout);
             await writeArtifact(stderrPath, stderr);
             const measured = {
@@ -147,7 +190,8 @@ export async function runMeasuredCommand(options) {
                 telemetryPath,
                 ok: exitCode === 0 && !spawnError && !timedOut,
                 error: spawnError,
-                resolvedCommand: resolution
+                resolvedCommand: resolution,
+                ...(bounded ? { timedOut, ...(outputLimit ? { outputLimit } : {}) } : {})
             };
             await writeArtifact(telemetryPath, JSON.stringify(measured, null, 2));
             resolve(measured);
@@ -156,10 +200,7 @@ export async function runMeasuredCommand(options) {
             timeout = setTimeout(() => {
                 timedOut = true;
                 spawnError = `Command timed out after ${options.timeoutMs}ms.`;
-                forceTerminateProcess(child.pid);
-                killGraceTimeout = setTimeout(() => {
-                    void settle(null);
-                }, KILL_GRACE_MS);
+                terminate();
             }, options.timeoutMs);
         }
         child.on("close", (exitCode) => {
@@ -168,6 +209,47 @@ export async function runMeasuredCommand(options) {
     });
     return result;
 }
+/**
+ * Accumulates one output stream. Without a limit it reproduces the legacy `text += String(chunk)`
+ * behavior exactly. With a limit it keeps raw bytes (so the cut is on a byte boundary), stops at the
+ * limit, and reports once when more output than the limit arrived.
+ */
+class OutputCollector {
+    limit;
+    text = "";
+    chunks = [];
+    bytes = 0;
+    exceeded = false;
+    constructor(limit) {
+        this.limit = limit;
+    }
+    /** Returns true exactly once: on the chunk that first exceeds the limit. */
+    push(chunk) {
+        if (this.limit === undefined) {
+            this.text += String(chunk);
+            return false;
+        }
+        if (this.exceeded) {
+            return false;
+        }
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), "utf8");
+        const remaining = this.limit - this.bytes;
+        if (buffer.length > remaining) {
+            if (remaining > 0) {
+                this.chunks.push(buffer.subarray(0, remaining));
+            }
+            this.bytes = this.limit;
+            this.exceeded = true;
+            return true;
+        }
+        this.chunks.push(buffer);
+        this.bytes += buffer.length;
+        return false;
+    }
+    toString() {
+        return this.limit === undefined ? this.text : Buffer.concat(this.chunks).toString("utf8");
+    }
+}
 async function writeArtifact(filePath, value) {
     await mkdir(path.dirname(filePath), { recursive: true });
     await writeFile(filePath, value, "utf8");

package/dist/src/evaluation/agentSuccess/applyPatchToSandbox.js

@@ -0,0 +1,37 @@
+import { excerptGitFailure, runSandboxGit } from "../benchmarkSandbox/index.js";
+import { extractPatchCandidate } from "./extractPatchCandidate.js";
+import { parseUnifiedDiff } from "./parseUnifiedDiff.js";
+import { DEFAULT_PATCH_BOUNDS } from "./patchTypes.js";
+import { validatePatchPolicy } from "./validatePatchPolicy.js";
+const APPLY_FLAGS = ["--index", "--whitespace=nowarn", "-"];
+/**
+ * Lab-owned patch application. The order is the safety contract:
+ * extract exactly one candidate -> parse -> policy -> `git apply --check --index` -> `git apply --index`.
+ * Nothing touches the sandbox until the check succeeds, so every earlier failure leaves it unchanged.
+ * `--unsafe-paths`, `--reject` and `--3way` are never used, and nothing the agent proposed is executed.
+ */
+export async function applyPatchToSandbox(options) {
+    const bounds = options.bounds ?? DEFAULT_PATCH_BOUNDS;
+    const extracted = extractPatchCandidate(options.rawProposal, bounds);
+    if (!extracted.ok)
+        return { outcome: "parse-failure", code: extracted.code, message: extracted.message };
+    const parsed = parseUnifiedDiff(extracted.patch);
+    if (!parsed.ok)
+        return { outcome: "parse-failure", code: parsed.code, message: parsed.message };
+    const policy = validatePatchPolicy(parsed.files, { protectedFiles: options.protectedFiles, bounds });
+    if (!policy.ok)
+        return { outcome: "policy-rejection", rejections: policy.rejections };
+    const check = await runSandboxGit(options.sandbox, ["apply", "--check", ...APPLY_FLAGS], {
+        stdin: extracted.patch,
+        label: "apply-check"
+    });
+    if (!check.ok)
+        return { outcome: "git-check-failure", message: excerptGitFailure(check) };
+    const apply = await runSandboxGit(options.sandbox, ["apply", ...APPLY_FLAGS], {
+        stdin: extracted.patch,
+        label: "apply"
+    });
+    if (!apply.ok)
+        return { outcome: "git-apply-failure", message: excerptGitFailure(apply) };
+    return { outcome: "success", files: policy.files };
+}

package/dist/src/evaluation/agentSuccess/assessBaseline.js

@@ -0,0 +1,23 @@
+/**
+ * Decides whether the unmodified benchmark can evaluate an implementation.
+ *
+ * Evaluable exactly when at least one task check fails (there is something to fix) and every regression
+ * check passes (there is nothing already broken), and no check was unable to produce a verdict. A check
+ * that timed out or errored is "not evaluable" rather than "failed": an indeterminate check cannot prove
+ * the task is unsolved. An invalid baseline is a benchmark defect, never an agent failure.
+ */
+export function assessBaseline(baseline) {
+    const reasons = [];
+    const all = [...baseline.taskResults, ...baseline.regressionResults];
+    if (baseline.taskResults.length === 0 || baseline.regressionResults.length === 0)
+        reasons.push("NO_CHECKS");
+    if (all.some((result) => result.status === "timeout" || result.status === "error"))
+        reasons.push("CHECK_NOT_EVALUABLE");
+    if (baseline.taskResults.length > 0 && !baseline.taskResults.some((result) => result.status === "failed")) {
+        if (!reasons.includes("CHECK_NOT_EVALUABLE"))
+            reasons.push("ALL_TASK_CHECKS_PASSED");
+    }
+    if (baseline.regressionResults.some((result) => result.status === "failed"))
+        reasons.push("REGRESSION_CHECK_FAILED");
+    return { evaluable: reasons.length === 0, reasons };
+}

package/dist/src/evaluation/agentSuccess/corpusTypes.js

@@ -0,0 +1,74 @@
+/**
+ * Contracts for the canonical agent-success implementation benchmark corpus. This is a separate contract family
+ * from the retrieval benchmark profiles (`benchmark-project-profiles.json`) and must not be merged into it.
+ */
+export const AGENT_SUCCESS_PROJECT_PROFILES_SCHEMA_VERSION = "my-dev-kit-lab-agent-success-project-profiles-v1";
+export const AGENT_SUCCESS_TASK_CATALOG_PATH = "benchmarks/contracts/agent-success-rate-tasks.json";
+export const AGENT_SUCCESS_PROJECT_PROFILES_PATH = "benchmarks/contracts/agent-success-rate-project-profiles.json";
+export const AGENT_SUCCESS_PROJECTS_DIRECTORY = "benchmarks/projects";
+export const AGENT_SUCCESS_CORPUS_PROJECT_IDS = ["agent-success-task-board-node", "agent-success-inventory-node"];
+/** The fixed catalog order. Three tasks per project: one localized, one cross-module, one broad-change. */
+export const AGENT_SUCCESS_CORPUS_TASKS = Object.freeze([
+    { id: "asr-board-title-normalization", project: "agent-success-task-board-node", locality: "localized" },
+    { id: "asr-board-import-idempotency", project: "agent-success-task-board-node", locality: "cross-module" },
+    { id: "asr-board-project-summary", project: "agent-success-task-board-node", locality: "broad-change" },
+    { id: "asr-inventory-quantity-boundary", project: "agent-success-inventory-node", locality: "localized" },
+    { id: "asr-inventory-reservation-atomicity", project: "agent-success-inventory-node", locality: "cross-module" },
+    { id: "asr-inventory-fulfillment-report", project: "agent-success-inventory-node", locality: "broad-change" }
+]);
+/** Files every project must contain, relative to the project root. */
+export const AGENT_SUCCESS_CORPUS_PROJECT_FILES = Object.freeze({
+    "agent-success-task-board-node": Object.freeze([
+        "README.md",
+        "package.json",
+        "src/validation.js",
+        "src/taskStore.js",
+        "src/taskService.js",
+        "src/projectSummary.js",
+        "src/index.js",
+        "tests/title-primary.check.mjs",
+        "tests/title-edge.check.mjs",
+        "tests/import-primary.check.mjs",
+        "tests/import-edge.check.mjs",
+        "tests/summary-primary.check.mjs",
+        "tests/summary-edge.check.mjs",
+        "tests/regression.check.mjs"
+    ]),
+    "agent-success-inventory-node": Object.freeze([
+        "README.md",
+        "package.json",
+        "src/quantity.js",
+        "src/inventoryStore.js",
+        "src/reservationService.js",
+        "src/fulfillmentReport.js",
+        "src/index.js",
+        "tests/quantity-primary.check.mjs",
+        "tests/quantity-edge.check.mjs",
+        "tests/reservation-primary.check.mjs",
+        "tests/reservation-edge.check.mjs",
+        "tests/report-primary.check.mjs",
+        "tests/report-edge.check.mjs",
+        "tests/regression.check.mjs"
+    ])
+});
+export const AGENT_SUCCESS_CORPUS_RAW_INCLUDE_GLOBS = Object.freeze(["src/**/*.js"]);
+/** Directory names that must never exist inside a canonical project. */
+export const AGENT_SUCCESS_CORPUS_FORBIDDEN_DIRECTORIES = Object.freeze([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    "lab-output"
+]);
+export class AgentSuccessCorpusError extends Error {
+    issues;
+    constructor(issues) {
+        super(`Invalid agent-success corpus: ${issues
+            .slice(0, 5)
+            .map((issue) => `${issue.path}: ${issue.code}`)
+            .join("; ")}${issues.length > 5 ? `; +${issues.length - 5} more` : ""}`);
+        this.name = "AgentSuccessCorpusError";
+        this.issues = [...issues];
+    }
+}

package/dist/src/evaluation/agentSuccess/extractPatchCandidate.js

@@ -0,0 +1,46 @@
+import { DEFAULT_PATCH_BOUNDS } from "./patchTypes.js";
+const FENCED_DIFF_BLOCK = /^```[ \t]*(?:diff|patch)[ \t]*\r?\n([\s\S]*?)^```[ \t]*$/gim;
+function looksLikeDiffStart(text) {
+    return text.startsWith("diff --git ") || text.startsWith("--- ");
+}
+/** Removes trailing line breaks only: a final context line that is a single space must survive. */
+function finalize(body) {
+    return `${body.replace(/(?:\r?\n)+$/, "")}\n`;
+}
+/**
+ * Extracts exactly one patch candidate from an agent's proposal: either one fenced `diff`/`patch` block, or
+ * the whole (trimmed) text when it is itself a unified diff. Ambiguity is rejected rather than guessed.
+ * Size and line bounds are enforced before any parsing.
+ */
+export function extractPatchCandidate(text, bounds = DEFAULT_PATCH_BOUNDS) {
+    if (typeof text !== "string" || text.trim() === "") {
+        return { ok: false, code: "EMPTY", message: "the proposal is empty." };
+    }
+    if (Buffer.byteLength(text, "utf8") > bounds.maxPatchBytes) {
+        return { ok: false, code: "PATCH_TOO_LARGE", message: `the proposal exceeds ${bounds.maxPatchBytes} bytes.` };
+    }
+    if (text.split("\n").length > bounds.maxPatchLines) {
+        return { ok: false, code: "PATCH_TOO_MANY_LINES", message: `the proposal exceeds ${bounds.maxPatchLines} lines.` };
+    }
+    const fenced = [...text.matchAll(FENCED_DIFF_BLOCK)];
+    if (fenced.length > 1) {
+        return { ok: false, code: "AMBIGUOUS_CANDIDATES", message: "more than one fenced diff/patch block was found." };
+    }
+    if (fenced.length === 1) {
+        const match = fenced[0];
+        const outside = text.slice(0, match.index) + text.slice((match.index ?? 0) + match[0].length);
+        if (/^diff --git /m.test(outside)) {
+            return { ok: false, code: "AMBIGUOUS_CANDIDATES", message: "a fenced block and a raw diff were both present." };
+        }
+        const body = match[1] ?? "";
+        if (body.trim() === "") {
+            return { ok: false, code: "EMPTY", message: "the fenced diff block is empty." };
+        }
+        return { ok: true, patch: finalize(body) };
+    }
+    const trimmed = text.trimStart();
+    if (looksLikeDiffStart(trimmed)) {
+        return { ok: true, patch: finalize(trimmed) };
+    }
+    return { ok: false, code: "NO_CANDIDATE", message: "no fenced diff/patch block and no raw unified diff was found." };
+}

package/dist/src/evaluation/agentSuccess/index.js

@@ -0,0 +1,14 @@
+export * from "./taskTypes.js";
+export { normalizeProjectRelativePath } from "./taskPaths.js";
+export { assertAgentSuccessTask, validateAgentSuccessTask } from "./validateAgentSuccessTask.js";
+export * from "./patchTypes.js";
+export { extractPatchCandidate } from "./extractPatchCandidate.js";
+export { parseUnifiedDiff } from "./parseUnifiedDiff.js";
+export { validatePatchPolicy } from "./validatePatchPolicy.js";
+export { applyPatchToSandbox } from "./applyPatchToSandbox.js";
+export * from "./verificationTypes.js";
+export { runVerificationCheck, runVerificationChecks } from "./runVerificationCheck.js";
+export { assessBaseline } from "./assessBaseline.js";
+export * from "./corpusTypes.js";
+export { assertAgentSuccessCorpus, validateAgentSuccessCorpus } from "./validateAgentSuccessCorpus.js";
+export { assertReadAgentSuccessCorpus, readAgentSuccessCorpus } from "./readAgentSuccessCorpus.js";

package/dist/src/evaluation/agentSuccess/parseUnifiedDiff.js

@@ -0,0 +1,210 @@
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+class PatchMalformed extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+function stripCr(line) {
+    return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+/** Mirrors `git apply -p1`: drop exactly one leading path component. */
+function stripOneComponent(rawPath) {
+    const slash = rawPath.indexOf("/");
+    if (slash < 0) {
+        throw new PatchMalformed("PATCH_MALFORMED", "a patch path has no directory component to strip.");
+    }
+    return rawPath.slice(slash + 1);
+}
+function parseHeaderPath(headerValue) {
+    const value = headerValue.split("\t")[0].trimEnd();
+    if (value.startsWith('"')) {
+        throw new PatchMalformed("UNSUPPORTED_PATH_QUOTING", "quoted patch paths are not supported.");
+    }
+    if (value === "/dev/null")
+        return null;
+    return stripOneComponent(value);
+}
+/** `diff --git <a> <b>`: returns the shared path when both sides agree after -p1 stripping, else null. */
+function parseGitHeaderPath(rest) {
+    if (rest.startsWith('"')) {
+        throw new PatchMalformed("UNSUPPORTED_PATH_QUOTING", "quoted patch paths are not supported.");
+    }
+    for (let index = rest.indexOf(" "); index >= 0; index = rest.indexOf(" ", index + 1)) {
+        const left = rest.slice(0, index);
+        const right = rest.slice(index + 1);
+        if (!left.includes("/") || !right.includes("/"))
+            continue;
+        if (stripOneComponent(left) === stripOneComponent(right))
+            return stripOneComponent(right);
+    }
+    return null;
+}
+function newFile(gitHeaderPath) {
+    return {
+        oldPath: null,
+        newPath: null,
+        gitHeaderPath,
+        isNew: false,
+        isDelete: false,
+        binary: false,
+        rename: false,
+        copy: false,
+        oldMode: null,
+        newMode: null,
+        subproject: false,
+        hunkCount: 0
+    };
+}
+/**
+ * Parses a Git/unified diff into per-file records with exact hunk accounting: every hunk must contain
+ * precisely the old/new line counts its header declares, so truncated or padded patches are rejected here
+ * instead of being half-understood. Only structure is recorded; policy decisions live in validatePatchPolicy.
+ */
+export function parseUnifiedDiff(patch) {
+    try {
+        const lines = patch.split("\n");
+        if (lines[lines.length - 1] === "")
+            lines.pop();
+        const files = [];
+        let index = 0;
+        const parseFileHeaders = (file) => {
+            const oldHeader = stripCr(lines[index]);
+            const plusLine = lines[index + 1];
+            if (plusLine === undefined || !stripCr(plusLine).startsWith("+++ ")) {
+                throw new PatchMalformed("PATCH_MALFORMED", 'a "---" header is not followed by a "+++" header.');
+            }
+            file.oldPath = parseHeaderPath(oldHeader.slice(4));
+            file.newPath = parseHeaderPath(stripCr(plusLine).slice(4));
+            if (file.oldPath === null)
+                file.isNew = true;
+            if (file.newPath === null)
+                file.isDelete = true;
+            index += 2;
+            while (index < lines.length && stripCr(lines[index]).startsWith("@@")) {
+                parseHunk(file);
+            }
+        };
+        const parseHunk = (file) => {
+            const match = HUNK_HEADER.exec(stripCr(lines[index]));
+            if (!match)
+                throw new PatchMalformed("PATCH_MALFORMED", "malformed hunk header.");
+            let oldRemaining = match[2] === undefined ? 1 : Number(match[2]);
+            let newRemaining = match[4] === undefined ? 1 : Number(match[4]);
+            index += 1;
+            while (oldRemaining > 0 || newRemaining > 0) {
+                const line = lines[index];
+                if (line === undefined)
+                    throw new PatchMalformed("PATCH_MALFORMED", "a hunk ends before its declared line counts.");
+                const marker = line.length === 0 ? " " : line[0];
+                if (marker === " ") {
+                    oldRemaining -= 1;
+                    newRemaining -= 1;
+                }
+                else if (marker === "-") {
+                    oldRemaining -= 1;
+                    if (line.startsWith("-Subproject commit "))
+                        file.subproject = true;
+                }
+                else if (marker === "+") {
+                    newRemaining -= 1;
+                    if (line.startsWith("+Subproject commit "))
+                        file.subproject = true;
+                }
+                else if (marker !== "\\") {
+                    throw new PatchMalformed("PATCH_MALFORMED", "unexpected line inside a hunk.");
+                }
+                if (oldRemaining < 0 || newRemaining < 0) {
+                    throw new PatchMalformed("PATCH_MALFORMED", "a hunk has more lines than its header declares.");
+                }
+                index += 1;
+            }
+            while (index < lines.length && lines[index].startsWith("\\"))
+                index += 1;
+            file.hunkCount += 1;
+        };
+        while (index < lines.length) {
+            const line = stripCr(lines[index]);
+            if (line.startsWith("diff --git ")) {
+                const file = newFile(parseGitHeaderPath(line.slice("diff --git ".length)));
+                index += 1;
+                while (index < lines.length) {
+                    const header = stripCr(lines[index]);
+                    if (header.startsWith("--- ") || header.startsWith("diff --git "))
+                        break;
+                    let match;
+                    if ((match = /^index [0-9a-f]+\.\.[0-9a-f]+(?: (\d+))?$/.exec(header))) {
+                        if (match[1]) {
+                            file.oldMode = match[1];
+                            file.newMode = match[1];
+                        }
+                    }
+                    else if ((match = /^old mode (\d+)$/.exec(header))) {
+                        file.oldMode = match[1];
+                    }
+                    else if ((match = /^new mode (\d+)$/.exec(header))) {
+                        file.newMode = match[1];
+                    }
+                    else if ((match = /^deleted file mode (\d+)$/.exec(header))) {
+                        file.isDelete = true;
+                        file.oldMode = match[1];
+                    }
+                    else if ((match = /^new file mode (\d+)$/.exec(header))) {
+                        file.isNew = true;
+                        file.newMode = match[1];
+                    }
+                    else if (/^(?:dis)?similarity index \d+%$/.test(header)) {
+                        // informational; rename/copy intent is carried by the from/to lines
+                    }
+                    else if (/^rename (?:from|to) /.test(header)) {
+                        file.rename = true;
+                    }
+                    else if (/^copy (?:from|to) /.test(header)) {
+                        file.copy = true;
+                    }
+                    else if (/^Binary files .* differ$/.test(header) || header === "GIT binary patch") {
+                        file.binary = true;
+                        index += 1;
+                        while (index < lines.length && !lines[index].startsWith("diff --git "))
+                            index += 1;
+                        break;
+                    }
+                    else {
+                        throw new PatchMalformed("PATCH_MALFORMED", "unrecognized extended header line.");
+                    }
+                    index += 1;
+                }
+                if (!file.binary && index < lines.length && stripCr(lines[index]).startsWith("--- ")) {
+                    parseFileHeaders(file);
+                }
+                files.push(file);
+            }
+            else if (line.startsWith("--- ") && lines[index + 1] !== undefined && stripCr(lines[index + 1]).startsWith("+++ ")) {
+                const file = newFile(null);
+                parseFileHeaders(file);
+                files.push(file);
+            }
+            else if (line.trim() === "") {
+                index += 1;
+            }
+            else {
+                throw new PatchMalformed("PATCH_MALFORMED", "unexpected content outside a file section.");
+            }
+        }
+        if (files.length === 0) {
+            throw new PatchMalformed("PATCH_MALFORMED", "the patch contains no file sections.");
+        }
+        for (const file of files) {
+            if ((file.oldPath ?? file.newPath ?? file.gitHeaderPath) === null && !file.rename && !file.copy) {
+                throw new PatchMalformed("PATCH_MALFORMED", "a file section has no determinable path.");
+            }
+        }
+        return { ok: true, files };
+    }
+    catch (error) {
+        if (error instanceof PatchMalformed)
+            return { ok: false, code: error.code, message: error.message };
+        throw error;
+    }
+}

package/dist/src/evaluation/agentSuccess/patchTypes.js

@@ -0,0 +1,5 @@
+export const DEFAULT_PATCH_BOUNDS = Object.freeze({
+    maxPatchBytes: 1_048_576,
+    maxChangedPaths: 64,
+    maxPatchLines: 20_000
+});