agentv 4.44.0-next.1 → 5.0.0-next.1

package/dist/{chunk-NCNDA3F6.js → chunk-UG4JHZYM.js}

@@ -21,18 +21,22 @@ import {
   readTranscriptJsonl,
   releaseSharedWorkspaceSetup,
   resolveRepoCloneUrl
-} from "./chunk-5DYGN547.js";
+} from "./chunk-GZJMODLW.js";
 
 // ../../packages/core/dist/index.js
-import { readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
+import { pathToFileURL } from "node:url";
+import { readFileSync } from "node:fs";
 import path2 from "node:path";
-import micromatch from "micromatch";
-import { readFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import path3 from "node:path";
+import micromatch from "micromatch";
+import { readFile as readFile2 } from "node:fs/promises";
+import path4 from "node:path";
 import { execFile, spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash as createHash2, randomBytes } from "node:crypto";
 import {
   existsSync,
   mkdirSync,
@@ -44,17 +48,17 @@ import {
 } from "node:fs";
 import { cp, lstat, mkdtemp, readdir, rm, stat } from "node:fs/promises";
 import os from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 import { promisify } from "node:util";
 import * as childProcess from "node:child_process";
 import { existsSync as existsSync2 } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
 import { homedir } from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
 import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 var TRACE_SESSION_SCHEMA_VERSION = "agentv.dashboard.trace_session.v1";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1478,6 +1482,429 @@ function isPrimitive(value) {
 function dropUndefined2(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
+var EXPERIMENT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml", ".ts", ".js", ".mts", ".mjs"]);
+var VALID_SANDBOXES = /* @__PURE__ */ new Set(["auto", "docker", "vercel"]);
+var VALID_REPEAT_STRATEGIES = /* @__PURE__ */ new Set([
+  "pass_at_k",
+  "mean",
+  "confidence_interval"
+]);
+function isExperimentFileReference(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return false;
+  }
+  return trimmed.includes("/") || trimmed.includes("\\") || EXPERIMENT_FILE_EXTENSIONS.has(path.extname(trimmed).toLowerCase());
+}
+function deriveExperimentNameFromPath(filePath) {
+  return path.basename(filePath).replace(/\.experiment\.(ya?ml|[cm]?[jt]s)$/i, "").replace(/\.(ya?ml|[cm]?[jt]s)$/i, "");
+}
+async function loadExperimentConfig(filePath) {
+  const resolvedPath = path.resolve(filePath);
+  const ext = path.extname(resolvedPath).toLowerCase();
+  let rawConfig;
+  if (ext === ".yaml" || ext === ".yml") {
+    rawConfig = parseYamlValue(await readFile(resolvedPath, "utf8"));
+  } else if (EXPERIMENT_FILE_EXTENSIONS.has(ext)) {
+    const moduleUrl = pathToFileURL(resolvedPath).href;
+    const mod = await import(moduleUrl);
+    rawConfig = mod.default ?? mod.config ?? mod;
+  } else {
+    throw new Error(
+      `Unsupported experiment file extension '${ext}'. Use .yaml, .yml, .ts, .js, .mts, or .mjs.`
+    );
+  }
+  return normalizeExperimentConfig(rawConfig, { sourcePath: resolvedPath });
+}
+function normalizeExperimentConfig(rawConfig, options = {}) {
+  if (!isRecord2(rawConfig)) {
+    throw new Error("Experiment config must be an object.");
+  }
+  const name = readOptionalString(rawConfig.name, "name");
+  const agent = readOptionalString(rawConfig.agent, "agent");
+  const target = readOptionalString(rawConfig.target, "target");
+  const targets = readTargets(rawConfig.targets);
+  const model = readOptionalString(rawConfig.model, "model");
+  const agentOptions = readOptionalRecord(rawConfig.agent_options ?? rawConfig.agentOptions);
+  const suites = readSuites(rawConfig.suites);
+  const scripts = readScriptArray(rawConfig.scripts, "scripts");
+  const repeat = readRepeat(rawConfig.repeat);
+  const runs = readOptionalPositiveInteger(rawConfig.runs, "runs");
+  if (repeat !== void 0 && runs !== void 0) {
+    throw new Error("Experiment repeat and runs cannot both be set. Use repeat for AgentV config.");
+  }
+  const earlyExit = readOptionalBoolean(rawConfig.early_exit ?? rawConfig.earlyExit, "early_exit");
+  const timeoutSeconds = readOptionalPositiveNumber(
+    rawConfig.timeout_seconds ?? rawConfig.timeoutSeconds,
+    "timeout_seconds"
+  );
+  const workers = readOptionalPositiveInteger(rawConfig.workers, "workers");
+  const budgetUsd = readOptionalPositiveNumber(
+    rawConfig.budget_usd ?? rawConfig.budgetUsd,
+    "budget_usd"
+  );
+  const sandbox = readOptionalSandbox(rawConfig.sandbox);
+  const workspace = readOptionalRecord(rawConfig.workspace);
+  const setup = readSetup(rawConfig.setup);
+  const configWithoutFingerprint = {
+    ...name !== void 0 && { name },
+    ...agent !== void 0 && { agent },
+    ...target !== void 0 && { target },
+    ...targets !== void 0 && { targets },
+    ...model !== void 0 && { model },
+    ...agentOptions !== void 0 && { agentOptions },
+    ...suites !== void 0 && { suites },
+    ...scripts !== void 0 && { scripts },
+    ...repeat !== void 0 && { repeat },
+    ...runs !== void 0 && { runs },
+    ...earlyExit !== void 0 && { earlyExit },
+    ...timeoutSeconds !== void 0 && { timeoutSeconds },
+    ...workers !== void 0 && { workers },
+    ...budgetUsd !== void 0 && { budgetUsd },
+    ...sandbox !== void 0 && { sandbox },
+    ...workspace !== void 0 && { workspace },
+    ...setup !== void 0 && { setup },
+    ...options.sourcePath !== void 0 && { sourcePath: options.sourcePath }
+  };
+  return {
+    ...configWithoutFingerprint,
+    fingerprint: fingerprintExperimentConfig(configWithoutFingerprint)
+  };
+}
+function fingerprintExperimentConfig(config) {
+  const stablePayload = toStableJsonValue(config);
+  return createHash("sha256").update(JSON.stringify(stablePayload)).digest("hex");
+}
+function buildExperimentArtifactMetadata(config) {
+  if (!config) {
+    return void 0;
+  }
+  const targets = config.targets?.map((target) => typeof target === "string" ? target : target.name).filter((target) => target.trim().length > 0);
+  return {
+    ...config.name !== void 0 && { name: config.name },
+    ...config.sourcePath !== void 0 && { source_path: config.sourcePath },
+    ...config.fingerprint !== void 0 && { fingerprint: config.fingerprint },
+    ...config.agent !== void 0 && { agent: config.agent },
+    ...config.target !== void 0 && { target: config.target },
+    ...targets && targets.length > 0 && { targets },
+    ...config.model !== void 0 && { model: config.model },
+    ...config.suites !== void 0 && { suites: config.suites.map(toSuiteArtifactMetadata) },
+    ...config.repeat !== void 0 && {
+      repeat: {
+        count: config.repeat.count,
+        strategy: config.repeat.strategy,
+        ...config.repeat.costLimitUsd !== void 0 && {
+          cost_limit_usd: config.repeat.costLimitUsd
+        }
+      }
+    },
+    ...config.runs !== void 0 && { runs: config.runs },
+    ...config.earlyExit !== void 0 && { early_exit: config.earlyExit },
+    ...config.timeoutSeconds !== void 0 && { timeout_seconds: config.timeoutSeconds },
+    ...config.workers !== void 0 && { workers: config.workers },
+    ...config.budgetUsd !== void 0 && { budget_usd: config.budgetUsd },
+    ...config.sandbox !== void 0 && { sandbox: config.sandbox }
+  };
+}
+function toSuiteArtifactMetadata(suite) {
+  return {
+    ref: suite.ref,
+    ...suite.select !== void 0 && {
+      select: {
+        test_ids: suite.select.testIds
+      }
+    }
+  };
+}
+function readRepeat(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (!isRecord2(raw)) {
+    throw new Error("Experiment repeat must be an object.");
+  }
+  const count = readRequiredPositiveInteger(raw.count, "repeat.count");
+  const strategy = readOptionalRepeatStrategy(raw.strategy);
+  const costLimitUsd = readOptionalNonNegativeNumber(
+    raw.cost_limit_usd ?? raw.costLimitUsd,
+    "repeat.cost_limit_usd"
+  );
+  return {
+    count,
+    strategy: strategy ?? "pass_at_k",
+    ...costLimitUsd !== void 0 && { costLimitUsd }
+  };
+}
+function readTargets(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error("Experiment targets must be an array.");
+  }
+  return raw.map((entry, index) => {
+    if (typeof entry === "string" && entry.trim().length > 0) {
+      return entry.trim();
+    }
+    if (!isRecord2(entry)) {
+      throw new Error(`Experiment targets[${index}] must be a string or object.`);
+    }
+    const name = readRequiredString(entry.name, `targets[${index}].name`);
+    const useTarget = readOptionalString(
+      entry.use_target ?? entry.useTarget,
+      `targets[${index}].use_target`
+    );
+    const hooks = readOptionalRecord(entry.hooks);
+    return {
+      name,
+      ...useTarget !== void 0 && { useTarget },
+      ...hooks !== void 0 && { hooks }
+    };
+  });
+}
+function readSuites(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error("Experiment suites must be an array.");
+  }
+  if (raw.length === 0) {
+    throw new Error("Experiment suites must not be empty.");
+  }
+  return raw.map((entry, index) => {
+    if (!isRecord2(entry)) {
+      throw new Error(`Experiment suites[${index}] must be an object.`);
+    }
+    const ref = readRequiredString(entry.ref, `suites[${index}].ref`);
+    const select = readSuiteSelect(entry.select, `suites[${index}].select`);
+    return {
+      ref,
+      ...select !== void 0 && { select }
+    };
+  });
+}
+function readSuiteSelect(raw, location) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (!isRecord2(raw)) {
+    throw new Error(`Experiment ${location} must be an object.`);
+  }
+  const testIds = readOptionalStringArray(raw.test_ids ?? raw.testIds, `${location}.test_ids`);
+  if (testIds === void 0) {
+    throw new Error(`Experiment ${location}.test_ids is required when select is set.`);
+  }
+  return { testIds };
+}
+function readScriptArray(raw, location) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error(`Experiment ${location} must be an array.`);
+  }
+  return raw.map((entry, index) => readScript(entry, `${location}[${index}]`));
+}
+function readSetup(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw === "function") {
+    return raw;
+  }
+  return readScriptArray(raw, "setup");
+}
+function readScript(raw, location) {
+  if (typeof raw === "string") {
+    const script2 = raw.trim();
+    if (!script2) {
+      throw new Error(`Experiment ${location} must not be empty.`);
+    }
+    return { script: script2 };
+  }
+  if (!isRecord2(raw)) {
+    throw new Error(`Experiment ${location} must be a string or object.`);
+  }
+  const command = readOptionalCommand(raw.command, `${location}.command`);
+  const script = readOptionalStringOrStringArray(raw.script, `${location}.script`);
+  if (command === void 0 && script === void 0) {
+    throw new Error(`Experiment ${location} must define command or script.`);
+  }
+  const timeoutSeconds = readOptionalPositiveNumber(
+    raw.timeout_seconds ?? raw.timeoutSeconds,
+    `${location}.timeout_seconds`
+  );
+  const cwd = readOptionalString(raw.cwd, `${location}.cwd`);
+  const env = readOptionalStringRecord(raw.env, `${location}.env`);
+  return {
+    ...command !== void 0 && { command },
+    ...script !== void 0 && { script },
+    ...timeoutSeconds !== void 0 && { timeoutSeconds },
+    ...cwd !== void 0 && { cwd },
+    ...env !== void 0 && { env }
+  };
+}
+function readOptionalCommand(raw, location) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw === "string") {
+    const command = raw.trim();
+    if (!command) {
+      throw new Error(`Experiment ${location} must not be empty.`);
+    }
+    return ["sh", "-c", command];
+  }
+  if (Array.isArray(raw) && raw.length > 0 && raw.every((entry) => typeof entry === "string" && entry.trim())) {
+    return raw.map((entry) => entry.trim());
+  }
+  throw new Error(`Experiment ${location} must be a string or string array.`);
+}
+function readOptionalStringOrStringArray(raw, location) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+      throw new Error(`Experiment ${location} must not be empty.`);
+    }
+    return trimmed;
+  }
+  if (Array.isArray(raw) && raw.length > 0 && raw.every((entry) => typeof entry === "string" && entry.trim())) {
+    return raw.map((entry) => entry.trim());
+  }
+  throw new Error(`Experiment ${location} must be a string or string array.`);
+}
+function readOptionalStringArray(raw, location) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (Array.isArray(raw) && raw.length > 0 && raw.every((entry) => typeof entry === "string" && entry.trim())) {
+    return raw.map((entry) => entry.trim());
+  }
+  throw new Error(`Experiment ${location} must be a non-empty string array.`);
+}
+function readOptionalString(raw, location) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    throw new Error(`Experiment ${location} must be a non-empty string.`);
+  }
+  return raw.trim();
+}
+function readRequiredString(raw, location) {
+  const value = readOptionalString(raw, location);
+  if (value === void 0) {
+    throw new Error(`Experiment ${location} is required.`);
+  }
+  return value;
+}
+function readRequiredPositiveInteger(raw, location) {
+  const value = readOptionalPositiveInteger(raw, location);
+  if (value === void 0) {
+    throw new Error(`Experiment ${location} is required.`);
+  }
+  return value;
+}
+function readOptionalBoolean(raw, location) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "boolean") {
+    throw new Error(`Experiment ${location} must be a boolean.`);
+  }
+  return raw;
+}
+function readOptionalRepeatStrategy(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string" || !VALID_REPEAT_STRATEGIES.has(raw)) {
+    throw new Error(
+      "Experiment repeat.strategy must be one of 'pass_at_k', 'mean', or 'confidence_interval'."
+    );
+  }
+  return raw;
+}
+function readOptionalPositiveInteger(raw, location) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 1) {
+    throw new Error(`Experiment ${location} must be a positive integer.`);
+  }
+  return raw;
+}
+function readOptionalNonNegativeNumber(raw, location) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0) {
+    throw new Error(`Experiment ${location} must be a non-negative number.`);
+  }
+  return raw;
+}
+function readOptionalPositiveNumber(raw, location) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) {
+    throw new Error(`Experiment ${location} must be a positive number.`);
+  }
+  return raw;
+}
+function readOptionalSandbox(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string" || !VALID_SANDBOXES.has(raw)) {
+    throw new Error("Experiment sandbox must be one of 'auto', 'docker', or 'vercel'.");
+  }
+  return raw;
+}
+function readOptionalRecord(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (!isRecord2(raw)) {
+    throw new Error("Experiment object field must be an object.");
+  }
+  return raw;
+}
+function readOptionalStringRecord(raw, location) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (!isRecord2(raw)) {
+    throw new Error(`Experiment ${location} must be an object.`);
+  }
+  const entries = Object.entries(raw);
+  if (!entries.every((entry) => typeof entry[1] === "string")) {
+    throw new Error(`Experiment ${location} values must be strings.`);
+  }
+  return Object.fromEntries(entries);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toStableJsonValue(value) {
+  if (typeof value === "function") {
+    return "[function]";
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(toStableJsonValue);
+  }
+  const record = value;
+  return Object.fromEntries(
+    Object.keys(record).sort().map((key) => [key, toStableJsonValue(record[key])])
+  );
+}
 function codeGraderInstruction(graderName, description) {
   const desc = description ? ` This grader: ${description}.` : "";
   return `Run \`agentv eval assert ${graderName} --agent-output <agent_output> --agent-input <original_prompt>\` and check the result.${desc} The command accepts --agent-output (the agent's full response text) and --agent-input (the original user prompt). It returns JSON on stdout: {"score": 0-1, "reasoning": "..."}. A score >= 0.5 means pass (exit 0); below 0.5 means fail (exit 1).`;
@@ -1717,7 +2144,7 @@ function transpileEvalYaml(suite, source = "EVAL.yaml") {
 function transpileEvalYamlFile(evalYamlPath) {
   const content = readFileSync(evalYamlPath, "utf8");
   const parsed = parseYamlValue(content);
-  return transpileEvalYaml(parsed, path.basename(evalYamlPath));
+  return transpileEvalYaml(parsed, path2.basename(evalYamlPath));
 }
 function getOutputFilenames(result) {
   const names = /* @__PURE__ */ new Map();
@@ -1782,7 +2209,7 @@ async function releaseUnselectedPoolSlots(setup, selectedSlotPath) {
   }
 }
 async function prepareEvalWorkspace(options) {
-  const evalPath = path2.resolve(options.testFilePath);
+  const evalPath = path3.resolve(options.testFilePath);
   const evalRunId = randomUUID();
   const evalCases = options.evalCases ?? await loadTests(evalPath, options.repoRoot, {
     verbose: options.verbose,
@@ -1794,7 +2221,7 @@ async function prepareEvalWorkspace(options) {
     filter: options.filter,
     evalPath
   });
-  const evalDir = path2.dirname(evalPath);
+  const evalDir = path3.dirname(evalPath);
   const workers = options.maxConcurrency ?? 1;
   const retainOnSuccess = options.retainOnSuccess ?? (options.keepWorkspaces ? "keep" : "cleanup");
   const retainOnFailure = options.retainOnFailure ?? (options.cleanupWorkspaces ? "cleanup" : "keep");
@@ -1905,6 +2332,13 @@ var AgentVConfigSchema = external_exports.object({
     /** Response cache directory */
     path: external_exports.string().optional()
   }).optional(),
+  /** Compatibility shorthand for experiments.default */
+  defaultExperiment: external_exports.string().optional(),
+  /** Experiment defaults */
+  experiments: external_exports.object({
+    /** Default experiment label or path used when eval runs omit --experiment */
+    default: external_exports.string().optional()
+  }).strict().optional(),
   /** Cost and duration limits */
   limits: external_exports.object({
     /** Maximum cost per run in USD */
@@ -1937,7 +2371,7 @@ var CONFIG_FILE_NAMES = [
 ];
 async function loadTsConfig(projectRoot) {
   const { existsSync: existsSync3 } = await import("node:fs");
-  const { pathToFileURL } = await import("node:url");
+  const { pathToFileURL: pathToFileURL2 } = await import("node:url");
   const { join } = await import("node:path");
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = join(projectRoot, fileName);
@@ -1945,7 +2379,7 @@ async function loadTsConfig(projectRoot) {
       continue;
     }
     try {
-      const fileUrl = pathToFileURL(filePath).href;
+      const fileUrl = pathToFileURL2(filePath).href;
       const mod = await import(fileUrl);
       const config = mod.default ?? mod;
       return AgentVConfigSchema.parse(config);
@@ -2062,11 +2496,11 @@ async function scanRepoDeps(evalFilePaths) {
   return { repos: [...seen.values()], errors };
 }
 async function extractReposFromEvalFile(filePath) {
-  const content = await readFile(filePath, "utf8");
+  const content = await readFile2(filePath, "utf8");
   const parsed = interpolateEnv(parseYamlValue(content), process.env);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
   const obj = parsed;
-  const evalFileDir = path3.dirname(path3.resolve(filePath));
+  const evalFileDir = path4.dirname(path4.resolve(filePath));
   const repos = [];
   const suiteRepos = await extractReposFromWorkspaceRaw(obj.workspace, evalFileDir);
   repos.push(...suiteRepos);
@@ -2082,8 +2516,8 @@ async function extractReposFromEvalFile(filePath) {
 }
 async function extractReposFromWorkspaceRaw(raw, evalFileDir) {
   if (typeof raw === "string") {
-    const workspaceFilePath = path3.resolve(evalFileDir, raw);
-    const content = await readFile(workspaceFilePath, "utf8");
+    const workspaceFilePath = path4.resolve(evalFileDir, raw);
+    const content = await readFile2(workspaceFilePath, "utf8");
     const parsed = interpolateEnv(parseYamlValue(content), process.env);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
     return extractReposFromObject(parsed);
@@ -2125,11 +2559,126 @@ var GIT_ENV_INHERIT_ALLOWLIST = /* @__PURE__ */ new Set([
   "GIT_USERNAME"
 ]);
 var DEFAULT_RESULTS_BRANCH = AGENTV_RESULTS_PRIMARY_REF;
-var MANAGED_RESULTS_REMOTE = "agentv-results";
 var GIT_EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 var RESULTS_REPO_GENESIS_MESSAGE = "chore(results): initialize AgentV results branch";
 var RESULTS_REPO_GENESIS_DATE = "@0 +0000";
 var RESULT_INDEX_FILENAME2 = "index.jsonl";
+var RESULTS_REPO_GITATTRIBUTES_FILE = ".gitattributes";
+var RESULTS_REPO_GITATTRIBUTES_CONTENT = `# Managed by AgentV. Artifact-aware merge so results sync never force-pushes.
+# Append-only run index: union concurrent appends (lines are orthogonal).
+index.jsonl merge=union
+# Editable run overlay (tags/feedback): 3-way JSON set/field union via the
+# agentv-json driver; a genuine scalar conflict falls through to a human merge.
+metadata/runs/**/*.json merge=agentv-json
+`;
+var RESULTS_JSON_MERGE_DRIVER_NAME = "agentv-json";
+var RESULTS_JSON_MERGE_DRIVER_SCRIPT = `#!/usr/bin/env node
+// AgentV results overlay merge driver (merge=agentv-json).
+//
+// Performs a 3-way merge of AgentV's editable JSON overlay files (run tags /
+// feedback). Tag lists merge as a 3-way set so concurrent add/remove are
+// commutative; display-only bookkeeping scalars that always differ between
+// writers (updated_at) are regenerated to the larger value instead of
+// conflicting. Content-derived concurrency tokens (tag_revision) are dropped on
+// merge so the reader recomputes a token matching the merged content rather than
+// carrying a stale token that could bypass optimistic-concurrency checks. Any
+// other genuinely diverging scalar exits non-zero, leaving the file conflicted
+// so the caller can route it to a human GitHub merge.
+//
+// Invoked by git as: node json-merge-driver.mjs %O %A %B %P
+//   %O ancestor, %A current (overwritten with the result), %B other, %P path.
+import { readFileSync, writeFileSync } from 'node:fs';
+
+const [, , ancestorFile, currentFile, otherFile] = process.argv;
+const CONFLICT = Symbol('conflict');
+// Scalars that legitimately differ on every write and carry no merge meaning.
+const REGENERABLE_SCALARS = new Set(['updated_at']);
+// Content-derived tokens (a hash of {tags, updated_at}) that guard optimistic
+// concurrency. Carrying either side's pre-merge token forward would let a stale
+// client whose token happens to match bypass the concurrency check and silently
+// overwrite the merged set, so we drop them and let the reader recompute a token
+// that matches the merged content.
+const DROP_ON_MERGE = new Set(['tag_revision']);
+
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return undefined;
+  }
+}
+
+function isPrimitiveArray(value) {
+  return (
+    Array.isArray(value) &&
+    value.every((entry) => entry === null || ['string', 'number', 'boolean'].includes(typeof entry))
+  );
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function mergeSet(base, a, b) {
+  const baseSet = new Set((isPrimitiveArray(base) ? base : []).map(String));
+  const aSet = new Set(a.map(String));
+  const bSet = new Set(b.map(String));
+  const removed = new Set();
+  for (const value of baseSet) {
+    if (!aSet.has(value) || !bSet.has(value)) removed.add(value);
+  }
+  const merged = [];
+  const seen = new Set();
+  for (const value of [...a, ...b]) {
+    const key = String(value);
+    if (!removed.has(key) && !seen.has(key)) {
+      seen.add(key);
+      merged.push(value);
+    }
+  }
+  return merged;
+}
+
+function merge3(base, a, b, key) {
+  if (JSON.stringify(a) === JSON.stringify(b)) return a;
+  if (JSON.stringify(a) === JSON.stringify(base)) return b;
+  if (JSON.stringify(b) === JSON.stringify(base)) return a;
+  if (isPrimitiveArray(a) && isPrimitiveArray(b)) return mergeSet(base, a, b);
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const keys = new Set([
+      ...Object.keys(a),
+      ...Object.keys(b),
+      ...(isPlainObject(base) ? Object.keys(base) : []),
+    ]);
+    const out = {};
+    for (const childKey of keys) {
+      if (DROP_ON_MERGE.has(childKey)) continue;
+      const merged = merge3(
+        isPlainObject(base) ? base[childKey] : undefined,
+        a[childKey],
+        b[childKey],
+        childKey,
+      );
+      if (merged === CONFLICT) return CONFLICT;
+      if (merged !== undefined) out[childKey] = merged;
+    }
+    return out;
+  }
+  if (REGENERABLE_SCALARS.has(key)) {
+    return [a, b].filter((value) => value !== undefined).sort().pop();
+  }
+  return CONFLICT;
+}
+
+const ancestor = readJson(ancestorFile) ?? {};
+const current = readJson(currentFile);
+const other = readJson(otherFile);
+if (current === undefined || other === undefined) process.exit(1);
+const result = merge3(ancestor, current, other, '');
+if (result === CONFLICT) process.exit(1);
+writeFileSync(currentFile, \`\${JSON.stringify(result, null, 2)}\\n\`);
+process.exit(0);
+`;
 var activeResultsRepoSyncs = /* @__PURE__ */ new Set();
 function sanitizeRepoSlug(repo) {
   return repo.trim().replace(/[^A-Za-z0-9._-]+/g, "-");
@@ -2144,13 +2693,13 @@ function withFriendlyGitHubAuthError(error) {
 }
 function expandHome(p) {
   if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
-    return path4.join(os.homedir(), p.slice(1));
+    return path5.join(os.homedir(), p.slice(1));
   }
   return p;
 }
 function resolveLocalPath(p, baseDir) {
   const expanded = expandHome(p);
-  return path4.isAbsolute(expanded) ? expanded : path4.resolve(baseDir, expanded);
+  return path5.isAbsolute(expanded) ? expanded : path5.resolve(baseDir, expanded);
 }
 function normalizeResultsConfig(config, options) {
   const baseDir = options?.baseDir ?? process.cwd();
@@ -2160,12 +2709,21 @@ function normalizeResultsConfig(config, options) {
   const repo = repoUrl ?? repoPath ?? "";
   const branch = config.branch?.trim() || (repoPath ? DEFAULT_RESULTS_BRANCH : void 0);
   const useStorageBranchWorktree = Boolean(repoPath || repoUrl && explicitClonePath && branch);
-  const remote = config.remote?.trim() || (repoUrl && useStorageBranchWorktree ? MANAGED_RESULTS_REMOTE : "origin");
+  const remote = config.remote?.trim() || "origin";
   const autoPush = config.sync?.auto_push ?? config.auto_push === true;
   const requirePush = config.sync?.require_push === true;
-  const pushConflictPolicy = config.sync?.push_conflict_policy ?? "block";
+  const configuredPushConflictPolicy = config.sync?.push_conflict_policy;
+  if (configuredPushConflictPolicy === "backup_and_force_push") {
+    throw new Error(
+      "results.sync.push_conflict_policy: 'backup_and_force_push' is no longer supported. Remove the field or set it to 'block'; AgentV never force-pushes result branches."
+    );
+  }
+  if (configuredPushConflictPolicy !== void 0 && configuredPushConflictPolicy !== "block") {
+    throw new Error("results.sync.push_conflict_policy must be 'block'");
+  }
+  const pushConflictPolicy = configuredPushConflictPolicy ?? "block";
   const resolvedRepoPath = repoPath ? resolveLocalPath(repoPath, baseDir) : void 0;
-  const resolvedPath = explicitClonePath ? resolveLocalPath(explicitClonePath, baseDir) : repoUrl ? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
+  const resolvedPath = explicitClonePath ? resolveLocalPath(explicitClonePath, baseDir) : repoUrl ? path5.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path5.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
   return {
     mode: "github",
     repo,
@@ -2181,18 +2739,26 @@ function normalizeResultsConfig(config, options) {
     storageBranchWorktree: useStorageBranchWorktree
   };
 }
+var GITHUB_OWNER_REPO_SHORTHAND = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+function isExplicitRemoteUrl(value) {
+  return value.includes("://") || value.startsWith("git@");
+}
 function resolveResultsRepoUrl(repo) {
-  if (repo.includes("://") || repo.startsWith("git@")) {
-    return repo;
+  const trimmed = repo.trim();
+  if (isExplicitRemoteUrl(trimmed)) {
+    return trimmed;
+  }
+  if (GITHUB_OWNER_REPO_SHORTHAND.test(trimmed)) {
+    return `https://github.com/${trimmed}.git`;
   }
-  return `https://github.com/${repo}.git`;
+  return trimmed;
 }
 function getResultsRepoLocalPaths(repo) {
-  const rootDir = path4.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
+  const rootDir = path5.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
   return {
     rootDir,
-    repoDir: path4.join(rootDir, "repo"),
-    statusFile: path4.join(rootDir, "status.json")
+    repoDir: path5.join(rootDir, "repo"),
+    statusFile: path5.join(rootDir, "status.json")
   };
 }
 function usesStorageBranchWorktree(config) {
@@ -2209,7 +2775,7 @@ function readPersistedStatus(statusFile) {
   }
 }
 function writePersistedStatus(statusFile, status) {
-  mkdirSync(path4.dirname(statusFile), { recursive: true });
+  mkdirSync(path5.dirname(statusFile), { recursive: true });
   writeFileSync(statusFile, `${JSON.stringify(status, null, 2)}
 `, "utf8");
 }
@@ -2447,22 +3013,95 @@ async function resolveGitTopLevel(repoDir) {
   const { stdout } = await runGit(["rev-parse", "--show-toplevel"], { cwd: repoDir });
   return stdout.trim() || repoDir;
 }
-async function ensureResultsRepoRemote(repoDir, config) {
-  if (!config.repo_url) {
+async function ensureResultsMergeConfig(repoDir) {
+  let gitDir;
+  try {
+    const { stdout } = await runGit(["rev-parse", "--git-common-dir"], { cwd: repoDir });
+    const resolved = stdout.trim();
+    gitDir = resolved ? path5.isAbsolute(resolved) ? resolved : path5.join(repoDir, resolved) : path5.join(repoDir, ".git");
+  } catch {
     return;
   }
-  const remoteUrl = resolveResultsRepoUrl(config.repo_url);
-  const { stdout } = await runGit(["remote", "get-url", config.remote], {
+  const driverScriptPath = path5.join(gitDir, "agentv", "json-merge-driver.mjs");
+  let scriptCurrent = false;
+  try {
+    scriptCurrent = readFileSync2(driverScriptPath, "utf8") === RESULTS_JSON_MERGE_DRIVER_SCRIPT;
+  } catch {
+    scriptCurrent = false;
+  }
+  if (!scriptCurrent) {
+    mkdirSync(path5.dirname(driverScriptPath), { recursive: true });
+    writeFileSync(driverScriptPath, RESULTS_JSON_MERGE_DRIVER_SCRIPT, { mode: 493 });
+  }
+  const driverCommand = `node ${JSON.stringify(driverScriptPath)} %O %A %B %P`;
+  await runGit(
+    ["config", `merge.${RESULTS_JSON_MERGE_DRIVER_NAME}.name`, "AgentV results overlay JSON union"],
+    { cwd: repoDir, check: false }
+  );
+  await runGit(["config", `merge.${RESULTS_JSON_MERGE_DRIVER_NAME}.driver`, driverCommand], {
     cwd: repoDir,
     check: false
   });
-  const existingUrl = stdout.trim();
-  if (!existingUrl) {
-    await runGit(["remote", "add", config.remote, remoteUrl], { cwd: repoDir });
+  writeResultsInfoAttributes(gitDir);
+}
+var RESULTS_INFO_ATTRIBUTES_BEGIN = "# >>> agentv results merge attributes >>>";
+var RESULTS_INFO_ATTRIBUTES_END = "# <<< agentv results merge attributes <<<";
+function writeResultsInfoAttributes(gitDir) {
+  const infoDir = path5.join(gitDir, "info");
+  const attributesPath = path5.join(infoDir, "attributes");
+  const managedBlock = `${RESULTS_INFO_ATTRIBUTES_BEGIN}
+${RESULTS_REPO_GITATTRIBUTES_CONTENT.trimEnd()}
+${RESULTS_INFO_ATTRIBUTES_END}
+`;
+  let existing = "";
+  try {
+    existing = readFileSync2(attributesPath, "utf8");
+  } catch {
+    existing = "";
+  }
+  const blockPattern = new RegExp(
+    `${escapeRegExp(RESULTS_INFO_ATTRIBUTES_BEGIN)}[\\s\\S]*?${escapeRegExp(
+      RESULTS_INFO_ATTRIBUTES_END
+    )}\\n?`
+  );
+  const withoutManaged = existing.replace(blockPattern, "");
+  const next = withoutManaged.length > 0 && !withoutManaged.endsWith("\n") ? `${withoutManaged}
+${managedBlock}` : `${withoutManaged}${managedBlock}`;
+  if (next === existing) {
+    return;
+  }
+  mkdirSync(infoDir, { recursive: true });
+  writeFileSync(attributesPath, next);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function addResultsGitattributesToIndex(repoDir, indexEnv) {
+  const { stdout: existing } = await runGit(
+    ["cat-file", "-p", `:0:${RESULTS_REPO_GITATTRIBUTES_FILE}`],
+    { cwd: repoDir, env: indexEnv, check: false }
+  );
+  if (existing === RESULTS_REPO_GITATTRIBUTES_CONTENT) {
     return;
   }
-  if (existingUrl !== remoteUrl) {
-    await runGit(["remote", "set-url", config.remote, remoteUrl], { cwd: repoDir });
+  const scratchDir = mkdtempSync(path5.join(os.tmpdir(), "agentv-results-attrs-"));
+  try {
+    const scratchFile = path5.join(scratchDir, RESULTS_REPO_GITATTRIBUTES_FILE);
+    writeFileSync(scratchFile, RESULTS_REPO_GITATTRIBUTES_CONTENT);
+    const { stdout: blob } = await runGit(["hash-object", "-w", "--no-filters", scratchFile], {
+      cwd: repoDir
+    });
+    await runGit(
+      [
+        "update-index",
+        "--add",
+        "--cacheinfo",
+        `100644,${blob.trim()},${RESULTS_REPO_GITATTRIBUTES_FILE}`
+      ],
+      { cwd: repoDir, env: indexEnv }
+    );
+  } finally {
+    rmSync(scratchDir, { recursive: true, force: true });
   }
 }
 function updateStatusFile(config, patch) {
@@ -2480,24 +3119,27 @@ async function ensureResultsRepoClone(config) {
     if (!await isGitRepository(normalized.repo_path)) {
       throw new Error(`Results repo_path is not a git repository: ${normalized.repo_path}`);
     }
-    return resolveGitTopLevel(normalized.repo_path);
+    const topLevel = await resolveGitTopLevel(normalized.repo_path);
+    await ensureResultsMergeConfig(topLevel);
+    return topLevel;
   }
   const cachePaths = getResultsRepoLocalPaths(normalized.repo);
   const cloneDir = normalized.path;
   mkdirSync(cachePaths.rootDir, { recursive: true });
-  mkdirSync(path4.dirname(cloneDir), { recursive: true });
+  mkdirSync(path5.dirname(cloneDir), { recursive: true });
   const cloneMissing = !existsSync(cloneDir);
-  const gitDir = path4.join(cloneDir, ".git");
+  const gitDir = path5.join(cloneDir, ".git");
   const cloneEmpty = !cloneMissing && !existsSync(gitDir) && (await readdir(cloneDir)).length === 0;
   if (cloneMissing || cloneEmpty) {
     try {
       await runGit([
         "clone",
         "--filter=blob:none",
+        ...normalized.remote === "origin" ? [] : ["--origin", normalized.remote],
         resolveResultsRepoUrl(normalized.repo_url ?? normalized.repo),
         cloneDir
       ]);
-      await ensureResultsRepoRemote(cloneDir, normalized);
+      await ensureResultsMergeConfig(cloneDir);
       return cloneDir;
     } catch (error) {
       updateStatusFile(normalized, { last_error: withFriendlyGitHubAuthError(error).message });
@@ -2507,7 +3149,7 @@ async function ensureResultsRepoClone(config) {
   if (!existsSync(gitDir)) {
     throw new Error(`Results repo clone path is not a git repository: ${cloneDir}`);
   }
-  await ensureResultsRepoRemote(cloneDir, normalized);
+  await ensureResultsMergeConfig(cloneDir);
   return cloneDir;
 }
 function getResultsRepoStatus(config) {
@@ -2653,7 +3295,7 @@ async function getStorageBranchWorktreeDirtyPaths(repoDir, config) {
   const comparisonRef = await gitRefExists(repoDir, localRef) ? localRef : await gitRefExists(repoDir, remoteRef) ? remoteRef : void 0;
   const dirtyPaths = [];
   for (const gitPath of safeDirtyPaths) {
-    const absolutePath = path4.join(repoDir, ...gitPath.split("/"));
+    const absolutePath = path5.join(repoDir, ...gitPath.split("/"));
     if (!existsSync(absolutePath)) {
       if (await readGitText(repoDir, comparisonRef, gitPath) !== void 0) {
         dirtyPaths.push(gitPath);
@@ -2759,7 +3401,7 @@ async function hasInProgressGitConflict(repoDir) {
       check: false
     });
     const markerPath = stdout.trim();
-    const resolvedMarkerPath = path4.isAbsolute(markerPath) ? markerPath : path4.join(repoDir, markerPath);
+    const resolvedMarkerPath = path5.isAbsolute(markerPath) ? markerPath : path5.join(repoDir, markerPath);
     if (markerPath && existsSync(resolvedMarkerPath)) {
       return true;
     }
@@ -2859,6 +3501,17 @@ var ResultsBranchPushConflictError = class extends Error {
     this.name = "ResultsBranchPushConflictError";
   }
 };
+function pendingMergeToWire(details) {
+  return {
+    temp_branch: details.tempBranch,
+    target_branch: details.targetBranch,
+    ...details.compareUrl !== void 0 && { compare_url: details.compareUrl },
+    ...details.contributedRunCount !== void 0 && {
+      contributed_run_count: details.contributedRunCount
+    },
+    created_at: details.createdAt
+  };
+}
 function pushDetailsToWire(details) {
   if (!details) {
     return {};
@@ -2876,7 +3529,11 @@ function pushDetailsToWire(details) {
     ...details.forcePushedCommit !== void 0 && {
       force_pushed_commit: details.forcePushedCommit
     },
-    ...details.leaseCommit !== void 0 && { lease_commit: details.leaseCommit }
+    ...details.leaseCommit !== void 0 && { lease_commit: details.leaseCommit },
+    ...details.autoMergedRemote === true && { auto_merged_remote: true },
+    ...details.pendingMerge !== void 0 && {
+      pending_merge: pendingMergeToWire(details.pendingMerge)
+    }
   };
 }
 function withBlockedStatus(status, blockReason, flags) {
@@ -2894,11 +3551,13 @@ function withPushConflictStatus(status, blockReason, details, flags) {
   return withBlockedStatus(
     {
       ...status,
-      sync_status: "push_conflict"
+      sync_status: flags.syncStatus ?? "push_conflict"
     },
     blockReason,
     {
-      ...flags,
+      pullPerformed: flags.pullPerformed,
+      pushPerformed: flags.pushPerformed,
+      commitCreated: flags.commitCreated,
       pushDetails: details
     }
   );
@@ -2914,12 +3573,12 @@ function withActionFlags(status, flags) {
   };
 }
 function isSafeResultsRepoPath(p) {
-  return RESULTS_REPO_TRACKED_DIRS.some((dir) => p === dir || p.startsWith(`${dir}/`));
+  return p === RESULTS_REPO_GITATTRIBUTES_FILE || RESULTS_REPO_TRACKED_DIRS.some((dir) => p === dir || p.startsWith(`${dir}/`));
 }
 async function existingTrackedResultsDirs(repoDir) {
   const targets = [];
   for (const dir of RESULTS_REPO_TRACKED_DIRS) {
-    if (existsSync(path4.join(repoDir, dir))) {
+    if (existsSync(path5.join(repoDir, dir))) {
       targets.push(dir);
       continue;
     }
@@ -2947,19 +3606,8 @@ function getPushTargetBranch(upstream, baseBranch, remote = "origin") {
   const prefix = `${remote}/`;
   return upstream?.startsWith(prefix) ? upstream.slice(prefix.length) : baseBranch;
 }
-function timestampForBackupRef(date = /* @__PURE__ */ new Date()) {
-  const pad = (value) => String(value).padStart(2, "0");
-  return `${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}T${pad(
-    date.getUTCHours()
-  )}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}Z`;
-}
-function slugifyBackupTargetBranch(branch) {
-  return branch.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "results";
-}
-function buildResultsBackupRef(targetBranch, remoteCommit) {
-  return `agentv/backups/${timestampForBackupRef()}-${slugifyBackupTargetBranch(
-    targetBranch
-  )}-${remoteCommit.slice(0, 7)}`;
+function formatShortSha(sha) {
+  return sha ? sha.slice(0, 12) : "unknown";
 }
 async function getCommitSha(repoDir, ref) {
   if (!ref) {
@@ -2976,91 +3624,309 @@ function isNonFastForwardPushError(error) {
   const text = gitErrorText(error);
   return text.includes("non-fast-forward") || text.includes("fetch first") || text.includes("tip is behind its remote") || text.includes("note about fast-forwards") || text.includes("stale info");
 }
-function formatShortSha(sha) {
-  return sha ? sha.slice(0, 12) : "unknown";
+var RESULTS_PUSH_MERGE_MAX_ATTEMPTS = 5;
+async function isAncestorCommit(repoDir, ancestor, descendant) {
+  const { exitCode } = await runGit(["merge-base", "--is-ancestor", ancestor, descendant], {
+    cwd: repoDir,
+    check: false
+  });
+  return exitCode === 0;
 }
-function buildBlockedPushConflictReason(details) {
-  return `Results branch push conflict on ${details.targetBranch}: remote ${formatShortSha(
-    details.remoteCommit
-  )}, local ${formatShortSha(details.localCommit)}. Configure results.sync.push_conflict_policy: backup_and_force_push to back up the remote ref before replacing it.`;
+async function getMergeBaseCommit(repoDir, a, b) {
+  const { stdout, exitCode } = await runGit(["merge-base", a, b], { cwd: repoDir, check: false });
+  const sha = stdout.trim();
+  return exitCode === 0 && sha.length > 0 ? sha : void 0;
 }
-async function resolveResultBranchPushConflict(params) {
-  await fetchResultsRepo(params.repoDir, params.normalized.remote, params.targetBranch);
-  const remoteRef = remoteBranchRef(params.targetBranch, params.normalized.remote);
-  const remoteCommit = await getCommitSha(params.repoDir, remoteRef);
-  const localCommit = await getCommitSha(params.repoDir, params.sourceRef);
-  const baseDetails = {
-    pushConflictPolicy: params.normalized.push_conflict_policy,
-    targetBranch: params.targetBranch,
-    ...remoteCommit !== void 0 && {
-      remoteCommit,
-      previousRemoteCommit: remoteCommit,
-      leaseCommit: remoteCommit
-    },
-    ...localCommit !== void 0 && { localCommit }
-  };
-  if (!remoteCommit) {
-    return {
-      blocked: true,
-      blockReason: `Results branch push conflict on ${params.targetBranch}: remote commit could not be resolved after fetch`,
-      details: baseDetails
-    };
+function buildNeedsHumanMergeReason(targetBranch, remoteCommit, localCommit) {
+  return `Results branch ${targetBranch} diverged from the remote and could not be auto-merged: a genuine content conflict in the editable overlay remains (remote ${formatShortSha(
+    remoteCommit
+  )}, local ${formatShortSha(
+    localCommit
+  )}). The remote branch is unchanged and no history was rewritten; resolve it with a GitHub pull request.`;
+}
+function timestampForResultsRef(date = /* @__PURE__ */ new Date()) {
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}T${pad(
+    date.getUTCHours()
+  )}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}Z`;
+}
+function slugifyResultsTargetBranch(branch) {
+  return branch.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "results";
+}
+function randomResultsRefToken() {
+  return randomBytes(4).toString("hex").slice(0, 6);
+}
+function buildResultsSyncBranchName(targetBranch, token = randomResultsRefToken()) {
+  return `agentv/results-sync/${timestampForResultsRef()}-${slugifyResultsTargetBranch(
+    targetBranch
+  )}-${token}`;
+}
+function buildResultsCompareUrl(remoteUrl, targetBranch, syncBranch) {
+  if (!remoteUrl) {
+    return void 0;
   }
-  if (params.normalized.push_conflict_policy === "block") {
-    return {
-      blocked: true,
-      blockReason: buildBlockedPushConflictReason(baseDetails),
-      details: baseDetails
-    };
+  const match = remoteUrl.trim().match(/github\.com[:/]([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i);
+  if (!match) {
+    return void 0;
   }
-  const backupRef = buildResultsBackupRef(params.targetBranch, remoteCommit);
-  const backupDetails = {
-    ...baseDetails,
-    backupRef,
-    backupCommit: remoteCommit
-  };
-  try {
-    await assertValidResultsBranchName(params.repoDir, backupRef);
-    await runGit(
-      ["push", "--porcelain", params.normalized.remote, `${remoteCommit}:refs/heads/${backupRef}`],
-      { cwd: params.repoDir }
-    );
-  } catch (error) {
-    return {
-      blocked: true,
-      blockReason: `Results branch backup creation failed for ${params.targetBranch} at ${formatShortSha(
-        remoteCommit
-      )}: ${getStatusMessage(error)}`,
-      details: backupDetails
-    };
+  const [, owner, repo] = match;
+  return `https://github.com/${owner}/${repo}/compare/${encodeURIComponent(
+    targetBranch
+  )}...${encodeURIComponent(syncBranch)}?expand=1`;
+}
+async function resolveRemotePushUrl(repoDir, remote) {
+  for (const args of [
+    ["remote", "get-url", "--push", remote],
+    ["remote", "get-url", remote]
+  ]) {
+    const { stdout, exitCode } = await runGit(args, { cwd: repoDir, check: false });
+    const url = stdout.trim();
+    if (exitCode === 0 && url.length > 0) {
+      return url;
+    }
   }
+  return void 0;
+}
+async function countContributedRunDirs(repoDir, remoteTargetCommit, sourceCommit) {
+  if (!remoteTargetCommit) {
+    return void 0;
+  }
+  const { stdout, exitCode } = await runGit(
+    [
+      "diff",
+      "--name-only",
+      `${remoteTargetCommit}...${sourceCommit}`,
+      "--",
+      `${RESULTS_REPO_RUNS_DIR}/`
+    ],
+    { cwd: repoDir, check: false }
+  );
+  if (exitCode !== 0) {
+    return void 0;
+  }
+  const runDirs = /* @__PURE__ */ new Set();
+  for (const line of stdout.split(/\r?\n/)) {
+    const file = line.trim();
+    if (!file) {
+      continue;
+    }
+    const segments = file.split("/");
+    if (segments[0] === RESULTS_REPO_RUNS_DIR && segments.length >= 3) {
+      runDirs.add(`${segments[0]}/${segments[1]}/${segments[2]}`);
+    }
+  }
+  return runDirs.size;
+}
+async function pushResultsSyncBranch(params) {
+  const { repoDir, remote, sourceCommit, targetBranch } = params;
+  const remoteTargetCommit = await getCommitSha(repoDir, remoteBranchRef(targetBranch, remote));
+  let syncBranch = buildResultsSyncBranchName(targetBranch);
+  await assertValidResultsBranchName(repoDir, syncBranch);
   try {
-    await runGit(
-      [
-        "push",
-        "--porcelain",
-        `--force-with-lease=refs/heads/${params.targetBranch}:${remoteCommit}`,
-        params.normalized.remote,
-        `${params.sourceRef}:refs/heads/${params.targetBranch}`
-      ],
-      { cwd: params.repoDir }
-    );
+    await runGit(["push", "--porcelain", remote, `${sourceCommit}:refs/heads/${syncBranch}`], {
+      cwd: repoDir
+    });
   } catch (error) {
-    return {
-      blocked: true,
-      blockReason: `Results branch force push lease failed for ${params.targetBranch}; remote changed after backup ${backupRef} was created with lease ${formatShortSha(
-        remoteCommit
-      )}: ${getStatusMessage(error)}`,
-      details: backupDetails
-    };
+    if (!isRefAlreadyExistsPushError(error)) {
+      throw error;
+    }
+    syncBranch = buildResultsSyncBranchName(targetBranch);
+    await assertValidResultsBranchName(repoDir, syncBranch);
+    await runGit(["push", "--porcelain", remote, `${sourceCommit}:refs/heads/${syncBranch}`], {
+      cwd: repoDir
+    });
   }
+  const compareUrl = buildResultsCompareUrl(
+    await resolveRemotePushUrl(repoDir, remote),
+    targetBranch,
+    syncBranch
+  );
+  const contributedRunCount = await countContributedRunDirs(
+    repoDir,
+    remoteTargetCommit,
+    sourceCommit
+  ).catch(() => void 0);
   return {
-    blocked: false,
-    details: {
-      ...backupDetails,
-      ...localCommit !== void 0 && { forcePushedCommit: localCommit }
+    tempBranch: syncBranch,
+    targetBranch,
+    ...compareUrl !== void 0 && { compareUrl },
+    ...contributedRunCount !== void 0 && { contributedRunCount },
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function isRefAlreadyExistsPushError(error) {
+  const text = gitErrorText(error);
+  return text.includes("already exists") || text.includes("cannot lock ref") || text.includes("reference already exists");
+}
+async function mergeRemoteIntoCheckedOutBranch(repoDir, remoteCommit) {
+  const args = ["merge", "--no-edit", "-m", "chore(results): merge remote results", remoteCommit];
+  let result = await runGit(args, {
+    cwd: repoDir,
+    check: false,
+    env: configuredGitCommitIdentityEnv()
+  });
+  if (result.exitCode !== 0 && isMissingGitIdentityError({ stderr: result.stderr })) {
+    await runGit(["merge", "--abort"], { cwd: repoDir, check: false });
+    result = await runGit(args, {
+      cwd: repoDir,
+      check: false,
+      env: { ...configuredGitCommitIdentityEnv(), ...fallbackResultsRepoCommitEnv() }
+    });
+  }
+  return result.exitCode;
+}
+async function resolveResultBranchPushConflict(params) {
+  await ensureResultsMergeConfig(params.repoDir);
+  const { repoDir, targetBranch } = params;
+  const remote = params.normalized.remote;
+  const localRef = params.sourceRef;
+  const remoteRef = remoteBranchRef(targetBranch, remote);
+  const branchCheckedOut = params.sourceRef === "HEAD";
+  let lastDetails = {
+    pushConflictPolicy: params.normalized.push_conflict_policy,
+    targetBranch
+  };
+  const buildHumanMergeOutcome = async (reason, details) => {
+    if (!details.localCommit) {
+      return { blocked: true, blockReason: reason, details, syncStatus: "needs_human_merge" };
+    }
+    try {
+      const pendingMerge = await pushResultsSyncBranch({
+        repoDir,
+        remote,
+        sourceCommit: details.localCommit,
+        targetBranch: details.targetBranch
+      });
+      return {
+        blocked: true,
+        blockReason: reason,
+        details: { ...details, pendingMerge },
+        syncStatus: "needs_human_merge"
+      };
+    } catch (error) {
+      return {
+        blocked: true,
+        blockReason: `${reason} (could not create the temp branch for the GitHub merge: ${getStatusMessage(
+          error
+        )})`,
+        details,
+        syncStatus: "needs_human_merge"
+      };
     }
   };
+  for (let attempt = 1; attempt <= RESULTS_PUSH_MERGE_MAX_ATTEMPTS; attempt += 1) {
+    await fetchResultsRepo(repoDir, remote, targetBranch);
+    const remoteCommit = await getCommitSha(repoDir, remoteRef);
+    const localCommit = await getCommitSha(repoDir, localRef);
+    const details = {
+      pushConflictPolicy: params.normalized.push_conflict_policy,
+      targetBranch,
+      ...remoteCommit !== void 0 && { remoteCommit, previousRemoteCommit: remoteCommit },
+      ...localCommit !== void 0 && { localCommit }
+    };
+    lastDetails = details;
+    if (!remoteCommit) {
+      return {
+        blocked: true,
+        blockReason: `Results branch push conflict on ${targetBranch}: remote commit could not be resolved after fetch`,
+        details,
+        syncStatus: "push_conflict"
+      };
+    }
+    if (!localCommit) {
+      return {
+        blocked: true,
+        blockReason: `Results branch push conflict on ${targetBranch}: local commit could not be resolved`,
+        details,
+        syncStatus: "push_conflict"
+      };
+    }
+    if (await isAncestorCommit(repoDir, localCommit, remoteCommit)) {
+      if (branchCheckedOut) {
+        await runGit(["merge", "--ff-only", remoteCommit], { cwd: repoDir, check: false });
+      } else {
+        await runGit(["update-ref", localRef, remoteCommit, localCommit], {
+          cwd: repoDir,
+          check: false
+        });
+      }
+      return { blocked: false, details };
+    }
+    let pushSpec = branchCheckedOut ? "HEAD" : localCommit;
+    let autoMergedRemote = false;
+    if (!await isAncestorCommit(repoDir, remoteCommit, localCommit)) {
+      if (branchCheckedOut) {
+        const exitCode = await mergeRemoteIntoCheckedOutBranch(repoDir, remoteCommit);
+        if (exitCode !== 0) {
+          await runGit(["merge", "--abort"], { cwd: repoDir, check: false });
+          return await buildHumanMergeOutcome(
+            buildNeedsHumanMergeReason(targetBranch, remoteCommit, localCommit),
+            details
+          );
+        }
+        pushSpec = "HEAD";
+        autoMergedRemote = true;
+      } else {
+        const base = await getMergeBaseCommit(repoDir, localCommit, remoteCommit);
+        if (!base) {
+          return await buildHumanMergeOutcome(
+            buildNeedsHumanMergeReason(targetBranch, remoteCommit, localCommit),
+            details
+          );
+        }
+        const merge = await runGit(
+          ["merge-tree", "--write-tree", `--merge-base=${base}`, localCommit, remoteCommit],
+          { cwd: repoDir, check: false }
+        );
+        const mergedTree = merge.stdout.trim().split(/\r?\n/)[0]?.trim();
+        if (merge.exitCode !== 0 || !mergedTree) {
+          return await buildHumanMergeOutcome(
+            buildNeedsHumanMergeReason(targetBranch, remoteCommit, localCommit),
+            details
+          );
+        }
+        const { stdout: mergeCommitOut } = await runGitWithFallbackCommitIdentity(
+          [
+            "commit-tree",
+            mergedTree,
+            "-p",
+            localCommit,
+            "-p",
+            remoteCommit,
+            "-m",
+            "chore(results): merge remote results"
+          ],
+          { cwd: repoDir }
+        );
+        pushSpec = mergeCommitOut.trim();
+        await runGit(["update-ref", localRef, pushSpec, localCommit], { cwd: repoDir });
+        autoMergedRemote = true;
+      }
+    }
+    try {
+      await runGit(["push", "--porcelain", remote, `${pushSpec}:refs/heads/${targetBranch}`], {
+        cwd: repoDir
+      });
+    } catch (error) {
+      if (isNonFastForwardPushError(error)) {
+        continue;
+      }
+      throw error;
+    }
+    const pushedCommit = await getCommitSha(repoDir, pushSpec) ?? localCommit;
+    return {
+      blocked: false,
+      details: {
+        ...details,
+        localCommit: pushedCommit,
+        ...autoMergedRemote && { autoMergedRemote }
+      }
+    };
+  }
+  return await buildHumanMergeOutcome(
+    `Results branch ${targetBranch} could not be reconciled after ${RESULTS_PUSH_MERGE_MAX_ATTEMPTS} attempts because the remote kept advancing; retry sync. The remote branch is unchanged.`,
+    lastDetails
+  );
 }
 async function statusFromInspection(normalized, repoDir) {
   return withGitInspection(
@@ -3087,7 +3953,6 @@ async function getResultsRepoSyncStatus(config) {
     };
   }
   try {
-    await ensureResultsRepoRemote(normalized.path, normalized);
     if (usesStorageBranchWorktree(normalized)) {
       await fetchResultsRepo(normalized.path, normalized.remote, normalized.branch).catch(
         () => void 0
@@ -3252,7 +4117,8 @@ async function syncResultsRepoForProject(config) {
           return withPushConflictStatus(status2, outcome.blockReason, outcome.details, {
             pullPerformed,
             pushPerformed,
-            commitCreated
+            commitCreated,
+            syncStatus: outcome.syncStatus
           });
         }
         pushPerformed = true;
@@ -3369,7 +4235,8 @@ async function syncResultsRepoForProject(config) {
                   return withPushConflictStatus(status2, outcome.blockReason, outcome.details, {
                     pullPerformed,
                     pushPerformed,
-                    commitCreated
+                    commitCreated,
+                    syncStatus: outcome.syncStatus
                   });
                 }
               } else {
@@ -3502,7 +4369,8 @@ async function syncResultsRepoForProject(config) {
         return withPushConflictStatus(status, outcome.blockReason, outcome.details, {
           pullPerformed,
           pushPerformed,
-          commitCreated
+          commitCreated,
+          syncStatus: outcome.syncStatus
         });
       }
       pushPerformed = true;
@@ -3587,7 +4455,8 @@ async function syncResultsRepoForProject(config) {
             return withPushConflictStatus(status, outcome.blockReason, outcome.details, {
               pullPerformed,
               pushPerformed,
-              commitCreated
+              commitCreated,
+              syncStatus: outcome.syncStatus
             });
           }
         } else {
@@ -3625,6 +4494,44 @@ async function syncResultsRepoForProject(config) {
     activeResultsRepoSyncs.delete(syncKey);
   }
 }
+async function fastForwardResultsTowardTarget(repoDir, normalized, targetBranch) {
+  const upstreamRef = remoteBranchRef(targetBranch, normalized.remote);
+  if (!await gitRefExists(repoDir, upstreamRef)) {
+    return;
+  }
+  const upstreamCommit = await getCommitSha(repoDir, upstreamRef);
+  if (!upstreamCommit) {
+    return;
+  }
+  if (usesStorageBranchWorktree(normalized) && normalized.branch) {
+    const localRef = `refs/heads/${normalized.branch}`;
+    if (!await gitRefExists(repoDir, localRef)) {
+      await runGit(["update-ref", localRef, upstreamCommit], { cwd: repoDir, check: false });
+      await runGit(["branch", "--set-upstream-to", upstreamRef, normalized.branch], {
+        cwd: repoDir,
+        check: false
+      });
+      return;
+    }
+    const localCommit = await getCommitSha(repoDir, localRef);
+    if (localCommit && await isAncestorCommit(repoDir, localCommit, upstreamCommit)) {
+      await runGit(["update-ref", localRef, upstreamCommit, localCommit], {
+        cwd: repoDir,
+        check: false
+      });
+    }
+    return;
+  }
+  await runGit(["merge", "--ff-only", upstreamRef], { cwd: repoDir, check: false });
+}
+async function confirmResultsMergeAndPull(config) {
+  const normalized = normalizeResultsConfig(config);
+  const repoDir = await ensureResultsRepoClone(normalized);
+  const targetBranch = normalized.branch ?? await resolveDefaultBranch(repoDir);
+  await fetchResultsRepo(repoDir, normalized.remote, normalized.branch).catch(() => void 0);
+  await fastForwardResultsTowardTarget(repoDir, normalized, targetBranch);
+  return syncResultsRepoForProject(config);
+}
 async function checkoutResultsRepoBranch(config, branchName) {
   const normalized = normalizeResultsConfig(config);
   const repoDir = await ensureResultsRepoClone(normalized);
@@ -3645,8 +4552,8 @@ async function prepareResultsRepoBranch(config, branchName) {
   const cloneDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(cloneDir);
   await fetchResultsRepo(cloneDir, normalized.remote);
-  const worktreeRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-repo-"));
-  const worktreeDir = path4.join(worktreeRoot, "repo");
+  const worktreeRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-results-repo-"));
+  const worktreeDir = path5.join(worktreeRoot, "repo");
   await runGit(
     ["worktree", "add", "-B", branchName, worktreeDir, `${normalized.remote}/${baseBranch}`],
     {
@@ -3668,12 +4575,12 @@ async function prepareResultsRepoBranch(config, branchName) {
 }
 async function stageResultsArtifacts(params) {
   rmSync(params.destinationDir, { recursive: true, force: true });
-  mkdirSync(path4.dirname(params.destinationDir), { recursive: true });
+  mkdirSync(path5.dirname(params.destinationDir), { recursive: true });
   await cp(params.sourceDir, params.destinationDir, { recursive: true });
 }
 function resolveResultsRepoRunsDir(config) {
   const normalized = normalizeResultsConfig(config);
-  return path4.join(normalized.path, RESULTS_REPO_RESULTS_DIR);
+  return path5.join(normalized.path, RESULTS_REPO_RESULTS_DIR);
 }
 async function directorySizeBytes(targetPath) {
   const entry = await stat(targetPath);
@@ -3682,7 +4589,7 @@ async function directorySizeBytes(targetPath) {
   }
   let total = 0;
   for (const child of await readdir(targetPath, { withFileTypes: true })) {
-    total += await directorySizeBytes(path4.join(targetPath, child.name));
+    total += await directorySizeBytes(path5.join(targetPath, child.name));
   }
   return total;
 }
@@ -3749,7 +4656,7 @@ async function assertValidResultsBranchName(repoDir, branch) {
   await runGit(["check-ref-format", "--branch", branch], { cwd: repoDir });
 }
 function normalizeDestinationPath(destinationPath) {
-  const normalized = destinationPath.split(path4.sep).join("/");
+  const normalized = destinationPath.split(path5.sep).join("/");
   const segments = normalized.split("/").filter(Boolean);
   if (segments.length === 0 || normalized.startsWith("/") || segments.some((segment) => segment === "..") || normalized.split("").some((char) => {
     const code = char.charCodeAt(0);
@@ -3763,7 +4670,7 @@ async function listSourceFiles(sourceDir) {
   const entries = [];
   async function visit(dir) {
     for (const entry of await readdir(dir, { withFileTypes: true })) {
-      const absolutePath = path4.join(dir, entry.name);
+      const absolutePath = path5.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(absolutePath);
       } else if (entry.isFile() || entry.isSymbolicLink()) {
@@ -3775,16 +4682,16 @@ async function listSourceFiles(sourceDir) {
   entries.sort();
   return entries;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function artifactSidecarPointers(record) {
-  if (!isRecord2(record) || !isRecord2(record.artifact_pointers)) {
+  if (!isRecord3(record) || !isRecord3(record.artifact_pointers)) {
     return [];
   }
   const pointers = [];
   for (const pointer of Object.values(record.artifact_pointers)) {
-    if (!isRecord2(pointer)) {
+    if (!isRecord3(pointer)) {
       continue;
     }
     if (pointer.ref !== AGENTV_RESULTS_ARTIFACTS_REF || typeof pointer.path !== "string") {
@@ -3799,14 +4706,14 @@ function artifactSidecarPointers(record) {
   return pointers;
 }
 function artifactSidecarKey(destinationPath, pointerPath) {
-  return path4.posix.join(
+  return path5.posix.join(
     RESULTS_REPO_RUNS_DIR,
     normalizeDestinationPath(destinationPath),
     normalizeDestinationPath(pointerPath)
   );
 }
 function collectArtifactSidecarPointers(sourceDir) {
-  const indexPath = path4.join(sourceDir, RESULT_INDEX_FILENAME2);
+  const indexPath = path5.join(sourceDir, RESULT_INDEX_FILENAME2);
   if (!existsSync(indexPath)) {
     return [];
   }
@@ -3825,16 +4732,16 @@ function collectArtifactSidecarPointers(sourceDir) {
 }
 function resolveArtifactPointerSourcePath(sourceDir, pointerPath) {
   const normalizedPointerPath = normalizeDestinationPath(pointerPath);
-  const sourceRoot = path4.resolve(sourceDir);
-  const sourcePath = path4.resolve(sourceRoot, ...normalizedPointerPath.split("/"));
-  const relative = path4.relative(sourceRoot, sourcePath);
-  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
+  const sourceRoot = path5.resolve(sourceDir);
+  const sourcePath = path5.resolve(sourceRoot, ...normalizedPointerPath.split("/"));
+  const relative = path5.relative(sourceRoot, sourcePath);
+  if (relative.startsWith("..") || path5.isAbsolute(relative)) {
     throw new Error(`Artifact pointer path escapes run directory: ${pointerPath}`);
   }
   return sourcePath;
 }
 function verifyArtifactPointerChecksum(pointer, content) {
-  const sha256 = createHash("sha256").update(content).digest("hex");
+  const sha256 = createHash2("sha256").update(content).digest("hex");
   if (pointer.sha256 && pointer.sha256 !== sha256) {
     throw new Error(`Artifact pointer checksum mismatch for ${pointer.path}`);
   }
@@ -3846,7 +4753,7 @@ async function prepareArtifactSidecar(params) {
   if (params.pointers.length === 0) {
     return void 0;
   }
-  const sidecarRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-artifact-sidecar-"));
+  const sidecarRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-artifact-sidecar-"));
   const copied = /* @__PURE__ */ new Set();
   const contentByPath = /* @__PURE__ */ new Map();
   try {
@@ -3862,8 +4769,8 @@ async function prepareArtifactSidecar(params) {
       if (copied.has(relativePointerPath)) {
         continue;
       }
-      const destinationPath = path4.join(sidecarRoot, ...relativePointerPath.split("/"));
-      mkdirSync(path4.dirname(destinationPath), { recursive: true });
+      const destinationPath = path5.join(sidecarRoot, ...relativePointerPath.split("/"));
+      mkdirSync(path5.dirname(destinationPath), { recursive: true });
       writeFileSync(destinationPath, content);
       copied.add(relativePointerPath);
     }
@@ -3890,12 +4797,12 @@ function rewritePublishedIndexLine(line, destinationPath) {
   } catch {
     return line;
   }
-  if (!isRecord2(record) || !isRecord2(record.artifact_pointers)) {
+  if (!isRecord3(record) || !isRecord3(record.artifact_pointers)) {
     return line;
   }
   let changed = false;
   for (const pointer of Object.values(record.artifact_pointers)) {
-    if (!isRecord2(pointer)) {
+    if (!isRecord3(pointer)) {
       continue;
     }
     if (pointer.ref !== AGENTV_RESULTS_ARTIFACTS_REF || typeof pointer.path !== "string") {
@@ -3913,26 +4820,26 @@ async function preparePublishedResultsSource(params) {
   if (params.pointers.length === 0) {
     return void 0;
   }
-  const publishedRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-published-"));
+  const publishedRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-results-published-"));
   const omittedPaths = new Set(
     params.pointers.map((pointer) => normalizeDestinationPath(pointer.path))
   );
   try {
     const sourceFiles = await listSourceFiles(params.sourceDir);
     for (const sourceFile of sourceFiles) {
-      const relativeFile = path4.relative(params.sourceDir, sourceFile).split(path4.sep).join("/");
-      const destinationFile = path4.join(publishedRoot, ...relativeFile.split("/"));
+      const relativeFile = path5.relative(params.sourceDir, sourceFile).split(path5.sep).join("/");
+      const destinationFile = path5.join(publishedRoot, ...relativeFile.split("/"));
       if (relativeFile === RESULT_INDEX_FILENAME2) {
         const original = readFileSync2(sourceFile, "utf8");
         const rewritten = original.split(/\r?\n/).map((line) => rewritePublishedIndexLine(line, params.destinationPath)).join("\n");
-        mkdirSync(path4.dirname(destinationFile), { recursive: true });
+        mkdirSync(path5.dirname(destinationFile), { recursive: true });
         writeFileSync(destinationFile, rewritten);
         continue;
       }
       if (omittedPaths.has(relativeFile)) {
         continue;
       }
-      mkdirSync(path4.dirname(destinationFile), { recursive: true });
+      mkdirSync(path5.dirname(destinationFile), { recursive: true });
       await cp(sourceFile, destinationFile, { dereference: false });
     }
   } catch (error) {
@@ -3999,8 +4906,8 @@ async function commitStorageBranchWorktreePaths(params) {
       normalized
     });
   }
-  const indexRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-index-"));
-  const indexFile = path4.join(indexRoot, "index");
+  const indexRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-results-index-"));
+  const indexFile = path5.join(indexRoot, "index");
   const indexEnv = { GIT_INDEX_FILE: indexFile };
   try {
     if (base.baseRef) {
@@ -4008,8 +4915,9 @@ async function commitStorageBranchWorktreePaths(params) {
     } else {
       await runGit(["read-tree", "--empty"], { cwd: params.repoDir, env: indexEnv });
     }
+    await addResultsGitattributesToIndex(params.repoDir, indexEnv);
     for (const gitPath of paths) {
-      const sourcePath = path4.join(params.repoDir, ...gitPath.split("/"));
+      const sourcePath = path5.join(params.repoDir, ...gitPath.split("/"));
       if (!existsSync(sourcePath)) {
         await runGit(["update-index", "--force-remove", "--", gitPath], {
           cwd: params.repoDir,
@@ -4075,7 +4983,7 @@ async function commitResultsRunWithTemporaryIndex(params) {
   await assertValidResultsBranchName(params.repoDir, normalized.branch);
   await ensureResultsBranchNotCheckedOut(params.repoDir, normalized);
   const destinationRunPath = normalizeDestinationPath(params.destinationPath);
-  const destinationTreePath = path4.posix.join(RESULTS_REPO_RUNS_DIR, destinationRunPath);
+  const destinationTreePath = path5.posix.join(RESULTS_REPO_RUNS_DIR, destinationRunPath);
   let base = await resolveStorageBranchBase({
     repoDir: params.repoDir,
     normalized,
@@ -4089,8 +4997,8 @@ async function commitResultsRunWithTemporaryIndex(params) {
       preferRemote: params.preferRemoteBase
     });
   }
-  const indexRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-index-"));
-  const indexFile = path4.join(indexRoot, "index");
+  const indexRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-results-index-"));
+  const indexFile = path5.join(indexRoot, "index");
   const indexEnv = { GIT_INDEX_FILE: indexFile };
   try {
     if (base.baseRef) {
@@ -4098,6 +5006,7 @@ async function commitResultsRunWithTemporaryIndex(params) {
     } else {
       await runGit(["read-tree", "--empty"], { cwd: params.repoDir, env: indexEnv });
     }
+    await addResultsGitattributesToIndex(params.repoDir, indexEnv);
     const existingPaths = await getExistingRunTreePaths(
       params.repoDir,
       base.baseRef,
@@ -4112,8 +5021,8 @@ async function commitResultsRunWithTemporaryIndex(params) {
     }
     const sourceFiles = await listSourceFiles(params.sourceDir);
     for (const sourceFile of sourceFiles) {
-      const relativeFile = path4.relative(params.sourceDir, sourceFile).split(path4.sep).join("/");
-      const destinationFile = path4.posix.join(destinationTreePath, relativeFile);
+      const relativeFile = path5.relative(params.sourceDir, sourceFile).split(path5.sep).join("/");
+      const destinationFile = path5.posix.join(destinationTreePath, relativeFile);
       const fileStat = await lstat(sourceFile);
       let mode = fileStat.mode & 73 ? "100755" : "100644";
       let hashInputPath = sourceFile;
@@ -4189,7 +5098,7 @@ function buildDirectPushResult(normalized, changed, outcome) {
     ...outcome?.blocked === true && {
       blocked: true,
       block_reason: outcome.blockReason,
-      sync_status: "push_conflict"
+      sync_status: outcome.syncStatus ?? "push_conflict"
     },
     ...pushDetailsToWire(details)
   };
@@ -4199,10 +5108,11 @@ function mergeDirectPushResults(normalized, results) {
   if (blocked) {
     return blocked;
   }
-  const detailed = [...results].reverse().find((result) => result.backup_ref !== void 0);
+  const detailed = [...results].reverse().find((result) => result.backup_ref !== void 0 || result.auto_merged_remote === true);
   return {
     changed: results.some((result) => result.changed),
     push_conflict_policy: normalized.push_conflict_policy,
+    ...detailed?.auto_merged_remote === true && { auto_merged_remote: true },
     ...detailed?.backup_ref !== void 0 && {
       backup_ref: detailed.backup_ref
     },
@@ -4386,7 +5296,7 @@ async function directPushResultsWithDetails(params) {
   }
 }
 function buildGitRunId(relativeRunPath) {
-  const normalized = relativeRunPath.split(path4.sep).join("/");
+  const normalized = relativeRunPath.split(path5.sep).join("/");
   const segments = normalized.split("/").filter(Boolean);
   if (segments.length >= 2) {
     const experiment = segments.slice(0, -1).join("/");
@@ -4398,8 +5308,8 @@ function buildGitRunId(relativeRunPath) {
   }
   return segments[0] ?? relativeRunPath;
 }
-function getRunExperiment(runId, benchmark) {
-  const experiment = benchmark.metadata?.experiment?.trim();
+function getRunExperiment(runId, summary) {
+  const experiment = summary?.metadata?.experiment?.trim();
   if (experiment) {
     return experiment;
   }
@@ -4523,7 +5433,7 @@ async function readGitResultArtifact(params) {
 }
 function buildWipBranchName(runDir) {
   const hostname = os.hostname().replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 40);
-  const runBasename = path4.basename(runDir).replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 60);
+  const runBasename = path5.basename(runDir).replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 60);
   return `agentv/wip/${hostname}/${runBasename}`;
 }
 async function setupWipWorktree(params) {
@@ -4542,8 +5452,8 @@ async function setupWipWorktree(params) {
   if (!baseRef) {
     throw new Error("Could not resolve a base ref for the WIP results branch");
   }
-  const worktreeRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-wip-"));
-  const worktreeDir = path4.join(worktreeRoot, "repo");
+  const worktreeRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-wip-"));
+  const worktreeDir = path5.join(worktreeRoot, "repo");
   await runGit(["worktree", "add", "-B", params.wipBranch, worktreeDir, baseRef], {
     cwd: cloneDir
   });
@@ -4562,7 +5472,7 @@ async function setupWipWorktree(params) {
   };
 }
 async function pushWipCheckpoint(params) {
-  const destinationDir = path4.join(
+  const destinationDir = path5.join(
     params.handle.worktreeDir,
     RESULTS_REPO_RUNS_DIR,
     params.destinationPath
@@ -4625,40 +5535,74 @@ async function listGitRuns(repoDir, ref = "origin/main") {
     }
     throw error;
   }
-  const benchmarkPaths = treeOut.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.endsWith("/benchmark.json"));
-  if (benchmarkPaths.length === 0) {
+  const treePaths = treeOut.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const indexPaths = treePaths.filter((line) => line.endsWith("/index.jsonl"));
+  if (indexPaths.length === 0) {
     return [];
   }
-  const batchInput = `${benchmarkPaths.map((benchmarkPath) => `${ref}:${benchmarkPath}`).join("\n")}
+  const batchInput = `${indexPaths.map((indexPath) => `${ref}:${indexPath}`).join("\n")}
 `;
   const blobs = parseGitBatchBlobs(await runGitBatch(repoDir, batchInput));
-  if (blobs.length !== benchmarkPaths.length) {
+  if (blobs.length !== indexPaths.length) {
     throw new Error(
-      `Expected ${benchmarkPaths.length} git blobs but received ${blobs.length} while listing results runs`
+      `Expected ${indexPaths.length} git blobs but received ${blobs.length} while listing results runs`
     );
   }
+  const summaryPaths = indexPaths.map((indexPath) => path5.posix.join(path5.posix.dirname(indexPath), "summary.json")).filter((summaryPath) => treePaths.includes(summaryPath));
+  const summaryByPath = /* @__PURE__ */ new Map();
+  if (summaryPaths.length > 0) {
+    const summaryBatchInput = `${summaryPaths.map((summaryPath) => `${ref}:${summaryPath}`).join("\n")}
+`;
+    const summaryBlobs = parseGitBatchBlobs(await runGitBatch(repoDir, summaryBatchInput));
+    for (let i = 0; i < summaryBlobs.length; i++) {
+      const summaryPath = summaryPaths[i];
+      const blob = summaryBlobs[i];
+      if (!summaryPath || !blob) continue;
+      summaryByPath.set(summaryPath, JSON.parse(blob.content.toString("utf8")));
+    }
+  }
   const runs = blobs.flatMap((blob, index) => {
-    const benchmarkPath = benchmarkPaths[index];
-    const benchmark = JSON.parse(blob.content.toString("utf8"));
-    const runDir = path4.posix.dirname(benchmarkPath);
-    const relativeRunPath = path4.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
+    const manifestPath = indexPaths[index];
+    const runDir = path5.posix.dirname(manifestPath);
+    const summaryPath = path5.posix.join(runDir, "summary.json");
+    const summary = summaryByPath.get(summaryPath);
+    const relativeRunPath = path5.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
     const runId = buildGitRunId(relativeRunPath);
-    const timestamp = benchmark.metadata?.timestamp?.trim() || path4.posix.basename(runDir);
-    const displayName = benchmark.metadata?.display_name?.trim() || path4.posix.basename(runDir);
-    const targets = benchmark.metadata?.targets ?? [];
-    const passRate = computeAveragePassRate(benchmark.run_summary);
+    const rows = blob.content.toString("utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap(
+      (line) => {
+        try {
+          return [
+            JSON.parse(line)
+          ];
+        } catch {
+          return [];
+        }
+      }
+    );
+    const rowTargets = [
+      ...new Set(rows.map((row) => row.target).filter((target) => !!target))
+    ];
+    const rowTestIds = [
+      ...new Set(rows.map((row) => row.test_id).filter((testId) => !!testId))
+    ];
+    const rowScores = rows.map((row) => row.score).filter((score) => typeof score === "number" && Number.isFinite(score));
+    const avgScore = rowScores.length > 0 ? rowScores.reduce((sum, score) => sum + score, 0) / rowScores.length : 0;
+    const timestamp = summary?.metadata?.timestamp?.trim() || rows[0]?.timestamp || path5.posix.basename(runDir);
+    const displayName = summary?.metadata?.display_name?.trim() || path5.posix.basename(runDir);
+    const targets = summary?.metadata?.targets ?? rowTargets;
+    const passRate = computeAveragePassRate(summary?.run_summary) ?? avgScore;
     return [
       {
         run_id: runId,
-        experiment: getRunExperiment(runId, benchmark),
+        experiment: getRunExperiment(runId, summary),
         timestamp,
         ...passRate !== void 0 && { pass_rate: passRate },
         ...targets.length === 1 && targets[0] ? { target: targets[0] } : {},
-        manifest_path: path4.posix.join(runDir, "index.jsonl"),
-        benchmark_path: benchmarkPath,
+        manifest_path: manifestPath,
+        ...summaryByPath.has(summaryPath) && { summary_path: summaryPath },
         display_name: displayName,
-        test_count: benchmark.metadata?.tests_run?.length ?? 0,
-        avg_score: 0,
+        test_count: summary?.metadata?.tests_run?.length ?? rowTestIds.length,
+        avg_score: avgScore,
         size_bytes: blob.size
       }
     ];
@@ -4667,9 +5611,9 @@ async function listGitRuns(repoDir, ref = "origin/main") {
   return runs;
 }
 async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main") {
-  const normalizedRunPath = relativeRunPath.split(path4.sep).join("/");
-  const runTreePath = path4.posix.join(RESULTS_REPO_RUNS_DIR, normalizedRunPath);
-  const targetRunDir = path4.join(repoDir, ...runTreePath.split("/"));
+  const normalizedRunPath = relativeRunPath.split(path5.sep).join("/");
+  const runTreePath = path5.posix.join(RESULTS_REPO_RUNS_DIR, normalizedRunPath);
+  const targetRunDir = path5.join(repoDir, ...runTreePath.split("/"));
   const { stdout: treeOut } = await runGit(["ls-tree", "-r", "--name-only", ref, runTreePath], {
     cwd: repoDir
   });
@@ -4685,16 +5629,16 @@ async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main")
       `Expected ${filePaths.length} git blobs but received ${blobs.length} while materializing results run`
     );
   }
-  const tempRoot = mkdtempSync(path4.join(repoDir, ".agentv-run-"));
-  const tempRunDir = path4.join(tempRoot, "run");
+  const tempRoot = mkdtempSync(path5.join(repoDir, ".agentv-run-"));
+  const tempRunDir = path5.join(tempRoot, "run");
   try {
     for (const [index, filePath] of filePaths.entries()) {
-      const relativeFilePath = path4.posix.relative(runTreePath, filePath);
-      const absolutePath = path4.join(tempRunDir, ...relativeFilePath.split("/"));
-      mkdirSync(path4.dirname(absolutePath), { recursive: true });
+      const relativeFilePath = path5.posix.relative(runTreePath, filePath);
+      const absolutePath = path5.join(tempRunDir, ...relativeFilePath.split("/"));
+      mkdirSync(path5.dirname(absolutePath), { recursive: true });
       writeFileSync(absolutePath, blobs[index].content);
     }
-    mkdirSync(path4.dirname(targetRunDir), { recursive: true });
+    mkdirSync(path5.dirname(targetRunDir), { recursive: true });
     try {
       renameSync(tempRunDir, targetRunDir);
     } catch (error) {
@@ -5679,7 +6623,7 @@ function extractResponseItemContent(content) {
   }
   return parts.length > 0 ? parts.join("") : void 0;
 }
-var DEFAULT_SESSIONS_DIR = () => path5.join(homedir(), ".codex", "sessions");
+var DEFAULT_SESSIONS_DIR = () => path6.join(homedir(), ".codex", "sessions");
 async function discoverCodexSessions(opts) {
   const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
@@ -5691,7 +6635,7 @@ async function discoverCodexSessions(opts) {
     return [];
   }
   for (const year of yearDirs) {
-    const yearPath = path5.join(sessionsDir, year);
+    const yearPath = path6.join(sessionsDir, year);
     let monthDirs;
     try {
       monthDirs = await readdir2(yearPath);
@@ -5699,7 +6643,7 @@ async function discoverCodexSessions(opts) {
       continue;
     }
     for (const month of monthDirs) {
-      const monthPath = path5.join(yearPath, month);
+      const monthPath = path6.join(yearPath, month);
       let dayDirs;
       try {
         dayDirs = await readdir2(monthPath);
@@ -5711,7 +6655,7 @@ async function discoverCodexSessions(opts) {
           const dirDate = `${year}-${month}-${day}`;
           if (dirDate !== opts.date) continue;
         }
-        const dayPath = path5.join(monthPath, day);
+        const dayPath = path6.join(monthPath, day);
         let files;
         try {
           files = await readdir2(dayPath);
@@ -5720,7 +6664,7 @@ async function discoverCodexSessions(opts) {
         }
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = path5.join(dayPath, file);
+          const filePath = path6.join(dayPath, file);
           const nameWithoutExt = file.replace(/\.jsonl$/, "");
           const parts = nameWithoutExt.split("-");
           const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
@@ -5739,7 +6683,7 @@ async function discoverCodexSessions(opts) {
   sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
   return sessions.slice(0, limit);
 }
-var DEFAULT_PROJECTS_DIR = () => path6.join(homedir2(), ".claude", "projects");
+var DEFAULT_PROJECTS_DIR = () => path7.join(homedir2(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -5758,7 +6702,7 @@ async function discoverClaudeSessions(opts) {
   }
   const sessions = [];
   for (const projectDir of projectDirs) {
-    const dirPath = path6.join(projectsDir, projectDir);
+    const dirPath = path7.join(projectsDir, projectDir);
     let entries;
     try {
       entries = await readdir3(dirPath);
@@ -5769,7 +6713,7 @@ async function discoverClaudeSessions(opts) {
       if (!entry.endsWith(".jsonl")) continue;
       const sessionId = entry.replace(/\.jsonl$/, "");
       if (opts?.sessionId && sessionId !== opts.sessionId) continue;
-      const filePath = path6.join(dirPath, entry);
+      const filePath = path7.join(dirPath, entry);
       let updatedAt;
       try {
         const fileStat = await stat3(filePath);
@@ -5844,6 +6788,12 @@ export {
   traceEnvelopeToTraceSessionResponse,
   buildTraceSpanTree,
   normalizeTraceArtifactToTraceSessionResponse,
+  isExperimentFileReference,
+  deriveExperimentNameFromPath,
+  loadExperimentConfig,
+  normalizeExperimentConfig,
+  fingerprintExperimentConfig,
+  buildExperimentArtifactMetadata,
   transpileEvalYaml,
   transpileEvalYamlFile,
   getOutputFilenames,
@@ -5857,9 +6807,11 @@ export {
   getResultsRepoLocalPaths,
   ensureResultsRepoClone,
   getResultsRepoStatus,
+  buildResultsCompareUrl,
   getResultsRepoSyncStatus,
   syncResultsRepo,
   syncResultsRepoForProject,
+  confirmResultsMergeAndPull,
   checkoutResultsRepoBranch,
   prepareResultsRepoBranch,
   stageResultsArtifacts,
@@ -5894,4 +6846,4 @@ export {
   TranscriptProvider,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-NCNDA3F6.js.map
+//# sourceMappingURL=chunk-UG4JHZYM.js.map