agentv 4.42.4 → 4.44.0-next.1

package/dist/{chunk-N6U3GXMF.js → chunk-CXHYTYHU.js}

@@ -2,13 +2,13 @@ import { createRequire } from 'node:module'; const require = createRequire(impor
 import {
   toSnakeCaseDeep as toSnakeCaseDeep2,
   writeArtifactsFromResults
-} from "./chunk-6SQDBXT7.js";
+} from "./chunk-KAGZRUO6.js";
 import {
   RunBudgetTracker,
   buildWipBranchName,
   deleteWipBranch,
   deriveCategory,
-  directPushResults,
+  directPushResultsWithDetails,
   directorySizeBytes,
   getResultsRepoSyncStatus,
   listGitRuns,
@@ -19,7 +19,7 @@ import {
   resolveResultsRepoRunsDir,
   setupWipWorktree,
   syncResultsRepoForProject
-} from "./chunk-RBOP5X36.js";
+} from "./chunk-NCNDA3F6.js";
 import {
   CLI_PLACEHOLDERS,
   COMMON_TARGET_SETTINGS,
@@ -67,7 +67,7 @@ import {
   toSnakeCaseDeep,
   traceFromTranscriptJsonLines,
   writeInitialBenchmarkArtifact
-} from "./chunk-ZPFM52HV.js";
+} from "./chunk-5DYGN547.js";
 
 // src/commands/eval/shared.ts
 import { constants } from "node:fs";
@@ -183,7 +183,7 @@ async function findRepoRoot(start) {
 // package.json
 var package_default = {
   name: "agentv",
-  version: "4.42.4",
+  version: "4.44.0-next.1",
   description: "CLI entry point for AgentV",
   type: "module",
   repository: {
@@ -200,19 +200,19 @@ var package_default = {
   files: ["dist", "README.md"],
   scripts: {
     dev: "bun src/cli.ts",
-    build: "tsup && bun run copy-readme",
+    build: "(cd ../../packages/sdk && bun run build) && tsup && bun run copy-readme",
     "copy-readme": `bun -e "import { cpSync } from 'fs'; cpSync('../../README.md', 'README.md')"`,
     prepublishOnly: `node -e "if(process.env.ALLOW_PUBLISH!=='1'){console.error('ERROR: Use bun run publish:next, then bun run promote:latest');process.exit(1)}"`,
-    typecheck: "tsc --noEmit",
+    typecheck: "(cd ../../packages/sdk && bun run build) && tsc --noEmit",
     lint: "biome check .",
     format: "biome format --write .",
     fix: "biome check --write .",
-    test: "bun test",
+    test: "(cd ../../packages/sdk && bun run build) && bun test",
     "test:watch": "bun test --watch"
   },
   dependencies: {
     "@anthropic-ai/claude-agent-sdk": "^0.2.49",
-    "@github/copilot-sdk": "^0.1.25",
+    "@github/copilot-sdk": "^1.0.3",
     "@hono/node-server": "^1.19.11",
     "@inquirer/prompts": "^8.2.1",
     "@earendil-works/pi-ai": "^0.74.0",
@@ -236,6 +236,7 @@ var package_default = {
   },
   devDependencies: {
     "@agentv/core": "workspace:*",
+    "@agentv/sdk": "workspace:*",
     "@types/semver": "^7.7.1",
     execa: "^9.3.0"
   }
@@ -351,16 +352,16 @@ function enforceRequiredVersion(requiredVersion, options) {
 import { existsSync as existsSync5 } from "node:fs";
 import path8 from "node:path";
 
-// src/commands/inspect/utils.ts
-import { readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "node:fs";
-import path5 from "node:path";
-
 // src/commands/eval/result-layout.ts
 import { existsSync, statSync } from "node:fs";
 import path3 from "node:path";
 var RESULT_INDEX_FILENAME = "index.jsonl";
-var RESULT_RUNS_DIRNAME = "runs";
+var RESULTS_DIRNAME = "results";
 var DEFAULT_EXPERIMENT_NAME = "default";
+var RESERVED_RESULTS_NAMESPACES = /* @__PURE__ */ new Set(["export", "metadata", "runs"]);
+function isReservedResultsNamespace(value) {
+  return value !== void 0 && RESERVED_RESULTS_NAMESPACES.has(value);
+}
 function normalizeExperimentName(experiment) {
   const trimmed = experiment?.trim();
   if (!trimmed) {
@@ -371,20 +372,26 @@ function normalizeExperimentName(experiment) {
       `Invalid experiment name "${trimmed}". Use only letters, numbers, ".", "_" and "-".`
     );
   }
+  if (isReservedResultsNamespace(trimmed)) {
+    throw new Error(`Invalid experiment name "${trimmed}". This results namespace is reserved.`);
+  }
   return trimmed;
 }
 function createRunDirName(timestamp = /* @__PURE__ */ new Date()) {
   return timestamp.toISOString().replace(/[:.]/g, "-");
 }
+function defaultRunPathSegments(experiment, runDirName) {
+  const normalizedExperiment = normalizeExperimentName(experiment);
+  return [normalizedExperiment, runDirName];
+}
+function buildResultsRootDir(cwd) {
+  return path3.join(cwd, ".agentv", RESULTS_DIRNAME);
+}
+function buildDefaultRunDirFromName(cwd, experiment, runDirName) {
+  return path3.join(buildResultsRootDir(cwd), ...defaultRunPathSegments(experiment, runDirName));
+}
 function buildDefaultRunDir(cwd, experiment, timestamp = /* @__PURE__ */ new Date()) {
-  return path3.join(
-    cwd,
-    ".agentv",
-    "results",
-    RESULT_RUNS_DIRNAME,
-    normalizeExperimentName(experiment),
-    createRunDirName(timestamp)
-  );
+  return buildDefaultRunDirFromName(cwd, experiment, createRunDirName(timestamp));
 }
 function resolveRunIndexPath(runDir) {
   return path3.join(runDir, RESULT_INDEX_FILENAME);
@@ -427,6 +434,21 @@ function resolveRunManifestPath(filePath) {
   }
   return filePath;
 }
+function relativeRunPathFromCwd(cwd, runDir) {
+  const relative = path3.relative(path3.resolve(buildResultsRootDir(cwd)), path3.resolve(runDir));
+  if (!relative || relative.startsWith("..") || path3.isAbsolute(relative)) {
+    return void 0;
+  }
+  const parts = relative.split(path3.sep).filter(Boolean);
+  if (parts.length < 2 || isReservedResultsNamespace(parts[0])) {
+    return void 0;
+  }
+  return parts.join(path3.posix.sep);
+}
+
+// src/commands/inspect/utils.ts
+import { readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "node:fs";
+import path5 from "node:path";
 
 // src/commands/results/manifest.ts
 import { existsSync as existsSync2, readFileSync } from "node:fs";
@@ -474,6 +496,21 @@ function readOptionalJson(baseDir, relativePath) {
     return void 0;
   }
 }
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function artifactPointerPath(pointer) {
+  if (typeof pointer === "string") {
+    return nonEmptyString(pointer);
+  }
+  if (!pointer) {
+    return void 0;
+  }
+  return nonEmptyString(pointer.path) ?? nonEmptyString(pointer.artifact_path) ?? nonEmptyString(pointer.relative_path);
+}
+function resolveTranscriptPath(record) {
+  return record.transcript_path ?? record.artifact_pointers?.transcript?.path ?? record.artifacts?.transcript_path ?? artifactPointerPath(record.transcript ?? record.artifacts?.transcript);
+}
 function hydrateInput(baseDir, record) {
   const inputText = readOptionalText(baseDir, record.input_path);
   if (!inputText) {
@@ -492,12 +529,14 @@ function hydrateOutput(baseDir, record) {
   }
   return responseText.trimEnd();
 }
-function hydrateTrace(baseDir, record) {
-  const transcriptText = readOptionalText(baseDir, record.transcript_path);
-  if (transcriptText) {
-    try {
-      return traceFromTranscriptJsonLines(parseJsonlLines(transcriptText));
-    } catch {
+function hydrateTrace(baseDir, record, options) {
+  if (options.hydrateTranscriptTrace !== false) {
+    const transcriptText = readOptionalText(baseDir, resolveTranscriptPath(record));
+    if (transcriptText) {
+      try {
+        return traceFromTranscriptJsonLines(parseJsonlLines(transcriptText));
+      } catch {
+      }
     }
   }
   const output = hydrateOutput(baseDir, record) ?? "";
@@ -510,7 +549,7 @@ function hydrateTrace(baseDir, record) {
     testId: record.test_id
   });
 }
-function hydrateManifestRecord(baseDir, record) {
+function hydrateManifestRecord(baseDir, record, options) {
   const grading = readOptionalJson(baseDir, record.grading_path);
   const timing = readOptionalJson(baseDir, record.timing_path);
   const testId = record.test_id ?? "unknown";
@@ -554,7 +593,7 @@ function hydrateManifestRecord(baseDir, record) {
     costUsd: record.cost_usd,
     input: hydrateInput(baseDir, record),
     output: hydrateOutput(baseDir, record) ?? "",
-    trace: hydrateTrace(baseDir, record),
+    trace: hydrateTrace(baseDir, record, options),
     metadata: record.metadata
   };
 }
@@ -568,12 +607,12 @@ function resolveResultSourcePath(source, cwd) {
   }
   return resolved;
 }
-function loadManifestResults(sourceFile) {
+function loadManifestResults(sourceFile, options = {}) {
   const resolvedSourceFile = resolveRunManifestPath(sourceFile);
   const content = readFileSync(resolvedSourceFile, "utf8");
   const records = parseResultRows(content, resolvedSourceFile);
   const baseDir = path4.dirname(resolvedSourceFile);
-  return records.map((record) => hydrateManifestRecord(baseDir, record));
+  return records.map((record) => hydrateManifestRecord(baseDir, record, options));
 }
 function loadLightweightResults(sourceFile) {
   const resolvedSourceFile = resolveRunManifestPath(sourceFile);
@@ -588,6 +627,7 @@ function loadLightweightResults(sourceFile) {
     scores: record.scores,
     executionStatus: record.execution_status,
     error: record.error,
+    costUsd: record.cost_usd,
     timestamp: record.timestamp
   }));
 }
@@ -961,24 +1001,27 @@ function collectRunManifestPaths(runsDir, currentDir, files) {
     }
   }
 }
-function listResultFilesFromRunsDir(runsDir, limit) {
+function listResultFilesFromRoot(runsDir, options) {
   const files = [];
   try {
     const entries = readdirSync(runsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
+        if (options?.skipTopLevelDirs?.has(entry.name) || isReservedResultsNamespace(entry.name)) {
+          continue;
+        }
         collectRunManifestPaths(runsDir, path5.join(runsDir, entry.name), files);
       }
     }
   } catch {
   }
   files.sort((a, b) => b.sortName.localeCompare(a.sortName));
-  const limited = limit !== void 0 && limit > 0 ? files.slice(0, limit) : files;
+  const limited = options?.limit !== void 0 && options.limit > 0 ? files.slice(0, options.limit) : files;
   const metas = [];
   for (const { filePath, displayName, runId } of limited) {
     try {
       const fileStat = statSync2(filePath);
-      const results = loadResultFile(filePath);
+      const results = loadLightweightResults(filePath);
       const testCount = results.length;
       const passCount = results.filter((r) => r.score >= DEFAULT_THRESHOLD).length;
       const passRate = testCount > 0 ? passCount / testCount : 0;
@@ -1001,10 +1044,19 @@ function listResultFilesFromRunsDir(runsDir, limit) {
   return metas;
 }
 function listResultFiles(cwd, limit) {
-  return listResultFilesFromRunsDir(
-    path5.join(cwd, ".agentv", "results", RESULT_RUNS_DIRNAME),
-    limit
-  );
+  const metas = listResultFilesFromRoot(buildResultsRootDir(cwd), {
+    skipTopLevelDirs: /* @__PURE__ */ new Set(["export", "metadata", "runs"])
+  }).sort((a, b) => {
+    const byTimestamp = b.timestamp.localeCompare(a.timestamp);
+    return byTimestamp !== 0 ? byTimestamp : b.displayName.localeCompare(a.displayName);
+  });
+  return limit !== void 0 && limit > 0 ? metas.slice(0, limit) : metas;
+}
+function listResultFilesFromRunsDir(runsDir, limit) {
+  return listResultFilesFromRoot(runsDir, {
+    limit,
+    skipTopLevelDirs: /* @__PURE__ */ new Set(["export", "metadata", "runs"])
+  });
 }
 function extractTimestampFromFilename(filename) {
   const match = filename.match(
@@ -1041,6 +1093,43 @@ import { execFileSync } from "node:child_process";
 import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import path7 from "node:path";
 
+// src/commands/results/run-state.ts
+import { createHash } from "node:crypto";
+var TagRevisionConflictError = class extends Error {
+  expectedRevision;
+  currentRevision;
+  constructor(expectedRevision, currentRevision) {
+    super("Run tags changed. Refresh the run and try again.");
+    this.name = "TagRevisionConflictError";
+    this.expectedRevision = expectedRevision;
+    this.currentRevision = currentRevision;
+  }
+};
+function createTagRevision(tags, updatedAt) {
+  const hash = createHash("sha256");
+  hash.update("agentv.run_tags.v1\0");
+  hash.update(JSON.stringify({ tags: [...tags], updated_at: updatedAt ?? "" }));
+  return `sha256:${hash.digest("hex")}`;
+}
+function normalizeTagRevision(input, tags, updatedAt) {
+  return typeof input === "string" && input.trim().length > 0 ? input : createTagRevision(tags, updatedAt);
+}
+function assertExpectedTagRevision(expectedRevision, currentRevision) {
+  if (expectedRevision !== void 0 && expectedRevision !== currentRevision) {
+    throw new TagRevisionConflictError(expectedRevision, currentRevision);
+  }
+}
+function materializeRunState(input) {
+  const tags = [...input?.tags ?? []];
+  return {
+    final_state: {
+      lifecycle: input?.lifecycle ?? "active",
+      tags
+    },
+    tag_revision: input?.tagRevision ?? createTagRevision(tags, input?.updatedAt)
+  };
+}
+
 // src/commands/results/run-tags.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, unlinkSync, writeFileSync } from "node:fs";
 import path6 from "node:path";
@@ -1061,10 +1150,11 @@ function readRunTags(manifestPath) {
     const tags = record.tags.filter(
       (t) => typeof t === "string" && t.trim().length > 0
     );
-    if (tags.length === 0) return void 0;
+    const updatedAt = typeof record.updated_at === "string" ? record.updated_at : "";
     return {
       tags,
-      updated_at: typeof record.updated_at === "string" ? record.updated_at : ""
+      updated_at: updatedAt,
+      tag_revision: normalizeTagRevision(record.tag_revision, tags, updatedAt || void 0)
     };
   } catch {
     return void 0;
@@ -1072,24 +1162,16 @@ function readRunTags(manifestPath) {
 }
 function writeRunTags(manifestPath, tags) {
   const cleaned = normalizeTags(tags);
-  if (cleaned.length === 0) {
-    deleteRunTags(manifestPath);
-    return null;
-  }
+  const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const entry = {
     tags: cleaned,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    updated_at: updatedAt,
+    tag_revision: createTagRevision(cleaned, updatedAt)
   };
   writeFileSync(runTagsPath(manifestPath), `${JSON.stringify(entry, null, 2)}
 `, "utf8");
   return entry;
 }
-function deleteRunTags(manifestPath) {
-  const fp = runTagsPath(manifestPath);
-  if (existsSync3(fp)) {
-    unlinkSync(fp);
-  }
-}
 function normalizeTags(tags) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
@@ -1172,15 +1254,23 @@ function parseTagsFile(content) {
   const record = parsed;
   if (!Array.isArray(record.tags)) return void 0;
   const tags = record.tags.filter((tag) => typeof tag === "string");
+  const updatedAt = typeof record.updated_at === "string" ? record.updated_at : void 0;
   return {
     tags,
-    updatedAt: typeof record.updated_at === "string" ? record.updated_at : void 0
+    updatedAt,
+    tagRevision: normalizeTagRevision(record.tag_revision, tags, updatedAt)
   };
 }
 function equalTags(a, b) {
   if (a.length !== b.length) return false;
   return a.every((tag, index) => tag === b[index]);
 }
+function equalTagFiles(a, b) {
+  if (a === void 0 || b === void 0) {
+    return a === b;
+  }
+  return equalTags(a.tags, b.tags) && a.updatedAt === b.updatedAt && a.tagRevision === b.tagRevision;
+}
 function resolveComparisonRef(repoDir) {
   const upstream = tryRunGit(repoDir, [
     "rev-parse",
@@ -1215,9 +1305,8 @@ function resolveRemoteRunMetadataPaths(repoDir, manifestPath) {
     overlayTagsGitPath: toGitPath(path7.relative(repoDir, overlayTagsPath))
   };
 }
-function readRemoteRunTagsContext(repoDir, manifestPath) {
+function readRemoteRunTagsContext(repoDir, manifestPath, comparisonRef = resolveComparisonRef(repoDir)) {
   const paths = resolveRemoteRunMetadataPaths(repoDir, manifestPath);
-  const comparisonRef = resolveComparisonRef(repoDir);
   const artifactTags = readTagsFile(paths.artifactTagsPath) ?? readTagsFromGit(repoDir, comparisonRef, paths.artifactTagsGitPath);
   const baseOverlayTags = readTagsFromGit(repoDir, comparisonRef, paths.overlayTagsGitPath);
   const localOverlayTags = readTagsFile(paths.overlayTagsPath);
@@ -1231,13 +1320,16 @@ function readRemoteRunTagsContext(repoDir, manifestPath) {
 function toRemoteRunTagState(context) {
   const remoteTags = context.baseOverlayTags?.tags ?? context.artifactTags?.tags ?? [];
   const effectiveTags = context.localOverlayTags?.tags ?? remoteTags;
-  const dirty = !equalTags(effectiveTags, remoteTags);
+  const dirty = context.localOverlayTags ? !equalTagFiles(context.localOverlayTags, context.baseOverlayTags) : !equalTags(effectiveTags, remoteTags);
+  const updatedAt = context.localOverlayTags?.updatedAt ?? context.baseOverlayTags?.updatedAt ?? context.artifactTags?.updatedAt;
+  const tagRevision = context.localOverlayTags?.tagRevision ?? context.baseOverlayTags?.tagRevision ?? context.artifactTags?.tagRevision ?? createTagRevision(effectiveTags, updatedAt);
   return {
     tags: effectiveTags,
     remoteTags,
     ...dirty && { pendingTags: effectiveTags },
     dirty,
-    updatedAt: context.localOverlayTags?.updatedAt ?? context.baseOverlayTags?.updatedAt ?? context.artifactTags?.updatedAt,
+    updatedAt,
+    tagRevision,
     metadataPath: context.paths.overlayTagsPath
   };
 }
@@ -1250,37 +1342,44 @@ function assertWritableResultsRepo(repoDir) {
     throw new Error(`Configured results repo is not a writable git checkout: ${repoDir}`);
   }
 }
-function readRemoteRunTags(repoDir, manifestPath) {
-  const context = readRemoteRunTagsContext(repoDir, manifestPath);
+function readRemoteRunTags(repoDir, manifestPath, comparisonRef) {
+  const context = readRemoteRunTagsContext(repoDir, manifestPath, comparisonRef);
   return toRemoteRunTagState(context);
 }
-function writeRemoteRunTags(repoDir, manifestPath, tags) {
+function writeRemoteRunTags(repoDir, manifestPath, tags, comparisonRef, expectedTagRevision) {
   assertWritableResultsRepo(repoDir);
   const cleaned = normalizeTags(tags);
-  const context = readRemoteRunTagsContext(repoDir, manifestPath);
+  const context = readRemoteRunTagsContext(repoDir, manifestPath, comparisonRef);
+  const currentState = toRemoteRunTagState(context);
+  assertExpectedTagRevision(expectedTagRevision, currentState.tagRevision);
   const remoteTags = context.baseOverlayTags?.tags ?? context.artifactTags?.tags ?? [];
-  if (equalTags(cleaned, remoteTags) && context.baseOverlayTags === void 0) {
+  if (cleaned.length > 0 && equalTags(cleaned, remoteTags) && context.baseOverlayTags === void 0) {
     rmSync(context.paths.overlayTagsPath, { force: true });
-    return readRemoteRunTags(repoDir, manifestPath);
+    return readRemoteRunTags(repoDir, manifestPath, comparisonRef);
   }
+  const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const entry = {
     tags: cleaned,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    updated_at: updatedAt,
+    tag_revision: createTagRevision(cleaned, updatedAt)
   };
   mkdirSync(path7.dirname(context.paths.overlayTagsPath), { recursive: true });
   writeFileSync2(context.paths.overlayTagsPath, `${JSON.stringify(entry, null, 2)}
 `, "utf8");
-  return readRemoteRunTags(repoDir, manifestPath);
+  return readRemoteRunTags(repoDir, manifestPath, comparisonRef);
 }
-function deleteRemoteRunTags(repoDir, manifestPath) {
-  return writeRemoteRunTags(repoDir, manifestPath, []);
+function deleteRemoteRunTags(repoDir, manifestPath, comparisonRef, expectedTagRevision) {
+  return writeRemoteRunTags(repoDir, manifestPath, [], comparisonRef, expectedTagRevision);
 }
 
 // src/commands/results/remote.ts
 var gitRunsCache = /* @__PURE__ */ new Map();
 var GIT_RUNS_CACHE_TTL_MS = 6e4;
 function getResultsStorageRef(config) {
-  return config.branch;
+  if (!config.branch) {
+    return void 0;
+  }
+  return config.storageBranchWorktree ? `refs/remotes/${config.remote}/${config.branch}` : config.branch;
 }
 function cachedListGitRuns(repoDir, ref) {
   const now = Date.now();
@@ -1307,19 +1406,36 @@ function invalidateGitRunsCache(repoDir) {
     }
   }
 }
+function relativeLocalRunPath(cwd, manifestPath) {
+  const manifestDir = path8.resolve(path8.dirname(manifestPath));
+  return relativeRunPathFromCwd(cwd, manifestDir);
+}
+function remoteMetadataManifestPath(cwd, config, meta) {
+  if (meta.source === "remote") {
+    return meta.path;
+  }
+  if (!meta.on_remote) {
+    return void 0;
+  }
+  const relativeRunPath = relativeLocalRunPath(cwd, meta.path);
+  if (!relativeRunPath) {
+    return void 0;
+  }
+  return path8.join(config.path, "runs", ...relativeRunPath.split("/"), "index.jsonl");
+}
 var REMOTE_RUN_PREFIX = "remote::";
 var SIZE_WARNING_BYTES = 10 * 1024 * 1024;
 function getStatusMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function getRelativeRunPath(cwd, runDir) {
-  const relative = path8.relative(path8.join(cwd, ".agentv", "results", "runs"), runDir);
-  if (!relative.startsWith("..") && !path8.isAbsolute(relative)) {
+  const relative = relativeRunPathFromCwd(cwd, runDir);
+  if (relative) {
     return relative;
   }
-  const experiment = path8.basename(path8.dirname(runDir));
-  const runName = path8.basename(runDir);
-  return experiment && experiment !== runName ? path8.join(experiment, runName) : runName;
+  throw new Error(
+    `Run workspace must use .agentv/results/<experiment>/<timestamp>: ${path8.resolve(runDir)}`
+  );
 }
 function buildCommitTitle(payload) {
   const passed = payload.results.filter((result) => result.score >= DEFAULT_THRESHOLD).length;
@@ -1349,13 +1465,16 @@ async function loadNormalizedResultsConfig(cwd, projectId, overrides) {
     ...project.results.branch !== void 0 && { branch: project.results.branch },
     ...project.results.remote !== void 0 && { remote: project.results.remote },
     ...project.results.path !== void 0 && { path: project.results.path },
-    ...(project.results.sync?.autoPush !== void 0 || project.results.sync?.requirePush !== void 0) && {
+    ...(project.results.sync?.autoPush !== void 0 || project.results.sync?.requirePush !== void 0 || project.results.sync?.pushConflictPolicy !== void 0) && {
       sync: {
         ...project.results.sync?.autoPush !== void 0 && {
           auto_push: project.results.sync.autoPush
         },
         ...project.results.sync?.requirePush !== void 0 && {
           require_push: project.results.sync.requirePush
+        },
+        ...project.results.sync?.pushConflictPolicy !== void 0 && {
+          push_conflict_policy: project.results.sync.pushConflictPolicy
         }
       }
     },
@@ -1381,13 +1500,16 @@ async function loadNormalizedResultsConfig(cwd, projectId, overrides) {
     ...overrides.branch !== void 0 ? { branch: overrides.branch } : baseConfig?.branch ? { branch: baseConfig.branch } : {},
     ...overrides.remote !== void 0 ? { remote: overrides.remote } : baseConfig?.remote ? { remote: baseConfig.remote } : {},
     ...repoOverride === void 0 && baseConfig?.repo_path === void 0 && baseConfig?.path ? { path: baseConfig.path } : {},
-    ...(overrides.auto_push !== void 0 || overrides.require_push !== void 0 || baseConfig?.auto_push !== void 0 || baseConfig?.require_push !== void 0) && {
+    ...(overrides.auto_push !== void 0 || overrides.require_push !== void 0 || overrides.push_conflict_policy !== void 0 || baseConfig?.auto_push !== void 0 || baseConfig?.require_push !== void 0 || baseConfig?.push_conflict_policy !== void 0) && {
       sync: {
         ...(overrides.auto_push ?? baseConfig?.auto_push) !== void 0 && {
           auto_push: overrides.auto_push ?? baseConfig?.auto_push
         },
         ...(overrides.require_push ?? baseConfig?.require_push) !== void 0 && {
           require_push: overrides.require_push ?? baseConfig?.require_push
+        },
+        ...(overrides.push_conflict_policy ?? baseConfig?.push_conflict_policy) !== void 0 && {
+          push_conflict_policy: overrides.push_conflict_policy ?? baseConfig?.push_conflict_policy
         }
       }
     },
@@ -1554,36 +1676,57 @@ async function ensureRemoteRunAvailable(cwd, meta, projectId) {
   await materializeGitRun(config.path, relativeRunPath, getResultsStorageRef(config));
 }
 async function readRemoteRunTagState(cwd, meta, projectId) {
-  if (meta.source !== "remote") return void 0;
+  if (meta.source !== "remote" && !meta.on_remote) return void 0;
   const config = await loadNormalizedResultsConfig(cwd, projectId);
   if (!config) return void 0;
+  const manifestPath = remoteMetadataManifestPath(cwd, config, meta);
+  if (!manifestPath) return void 0;
   try {
-    return readRemoteRunTags(config.path, meta.path);
+    return readRemoteRunTags(config.path, manifestPath, getResultsStorageRef(config));
   } catch {
     return void 0;
   }
 }
-async function setRemoteRunTags(cwd, meta, tags, projectId) {
-  if (meta.source !== "remote") {
+async function setRemoteRunTags(cwd, meta, tags, projectId, expectedTagRevision) {
+  if (meta.source !== "remote" && !meta.on_remote) {
     throw new Error("Remote metadata can only be set on remote runs");
   }
   const config = await loadNormalizedResultsConfig(cwd, projectId);
   if (!config) {
     throw new Error("Writable results repo is not configured for remote metadata");
   }
+  const manifestPath = remoteMetadataManifestPath(cwd, config, meta);
+  if (!manifestPath) {
+    throw new Error("Remote metadata can only be set on remote runs");
+  }
   assertWritableResultsRepo(config.path);
-  return writeRemoteRunTags(config.path, meta.path, tags);
+  return writeRemoteRunTags(
+    config.path,
+    manifestPath,
+    tags,
+    getResultsStorageRef(config),
+    expectedTagRevision
+  );
 }
-async function clearRemoteRunTags(cwd, meta, projectId) {
-  if (meta.source !== "remote") {
+async function clearRemoteRunTags(cwd, meta, projectId, expectedTagRevision) {
+  if (meta.source !== "remote" && !meta.on_remote) {
     throw new Error("Remote metadata can only be removed from remote runs");
   }
   const config = await loadNormalizedResultsConfig(cwd, projectId);
   if (!config) {
     throw new Error("Writable results repo is not configured for remote metadata");
   }
+  const manifestPath = remoteMetadataManifestPath(cwd, config, meta);
+  if (!manifestPath) {
+    throw new Error("Remote metadata can only be removed from remote runs");
+  }
   assertWritableResultsRepo(config.path);
-  return deleteRemoteRunTags(config.path, meta.path);
+  return deleteRemoteRunTags(
+    config.path,
+    manifestPath,
+    getResultsStorageRef(config),
+    expectedTagRevision
+  );
 }
 async function maybeAutoExportRunArtifacts(payload) {
   const config = await loadNormalizedResultsConfig(
@@ -1598,13 +1741,20 @@ async function maybeAutoExportRunArtifacts(payload) {
     await maybeWarnLargeArtifact(payload.run_dir);
     const relativeRunPath = getRelativeRunPath(payload.cwd, payload.run_dir);
     const commitTitle = buildCommitTitle(payload);
-    const pushed = await directPushResults({
+    const pushResult = await directPushResultsWithDetails({
       config,
       sourceDir: payload.run_dir,
       destinationPath: relativeRunPath,
       commitMessage: commitTitle
     });
-    if (!pushed) {
+    if (pushResult.blocked) {
+      if (config.require_push) {
+        throw new Error(pushResult.block_reason ?? "Results branch push conflict");
+      }
+      console.warn(`Warning: skipping results export: ${pushResult.block_reason}`);
+      return "failed";
+    }
+    if (!pushResult.changed) {
       console.warn("Warning: results export produced no git changes.");
       return "already_published";
     }
@@ -1612,6 +1762,11 @@ async function maybeAutoExportRunArtifacts(payload) {
     console.log(
       `Results ${pushLabel} to ${config.repo} (${config.branch ?? "default branch"}:${relativeRunPath})`
     );
+    if (pushResult.backup_ref) {
+      console.log(
+        `Backed up previous remote ${pushResult.target_branch ?? config.branch ?? "results branch"} at ${pushResult.backup_ref}`
+      );
+    }
     return "published";
   } catch (error) {
     if (config.require_push) {
@@ -2728,20 +2883,7 @@ async function validateEvalFile(filePath) {
       });
     }
   }
-  const suiteInput = parsed.input;
-  if (suiteInput !== void 0) {
-    if (typeof suiteInput === "string") {
-    } else if (Array.isArray(suiteInput)) {
-      validateMessages(suiteInput, "input", absolutePath, errors);
-    } else {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location: "input",
-        message: "Invalid suite-level 'input' field (must be a string or array of messages)"
-      });
-    }
-  }
+  validateInputField(parsed.input, "input", absolutePath, errors);
   const cases = parsed.tests;
   if (typeof cases === "string") {
     await validateWorkspaceConfig(parsed.workspace, absolutePath, errors, "workspace");
@@ -2881,27 +3023,9 @@ async function validateEvalFile(filePath) {
         message: "Invalid 'criteria' field (must be a non-empty string if provided)"
       });
     }
-    const inputField = evalCase.input;
-    if (inputField !== void 0) {
-      if (typeof inputField === "string") {
-      } else if (Array.isArray(inputField)) {
-        validateMessages(inputField, `${location}.input`, absolutePath, errors);
-      } else {
-        errors.push({
-          severity: "error",
-          filePath: absolutePath,
-          location: `${location}.input`,
-          message: "Invalid 'input' field (must be a string or array of messages)"
-        });
-      }
-    } else {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location: `${location}.input`,
-        message: "Missing 'input' field (must be a string or array of messages)"
-      });
-    }
+    validateInputField(evalCase.input, `${location}.input`, absolutePath, errors, {
+      required: true
+    });
     const expectedOutputField = evalCase.expected_output;
     if (expectedOutputField !== void 0) {
       if (typeof expectedOutputField === "string") {
@@ -3053,7 +3177,7 @@ function validateMessages(messages, location, filePath, errors) {
       continue;
     }
     const role = message.role;
-    const validRoles = ["system", "user", "assistant"];
+    const validRoles = ["system", "user", "assistant", "tool"];
     if (!validRoles.includes(role)) {
       errors.push({
         severity: "error",
@@ -3116,6 +3240,39 @@ function validateMessages(messages, location, filePath, errors) {
     }
   }
 }
+function validateInputField(inputField, location, filePath, errors, options = {}) {
+  if (inputField === void 0) {
+    if (options.required) {
+      errors.push({
+        severity: "error",
+        filePath,
+        location,
+        message: "Missing 'input' field (must be a string, object, or array of messages)"
+      });
+    }
+    return;
+  }
+  if (typeof inputField === "string") {
+    return;
+  }
+  if (Array.isArray(inputField)) {
+    validateMessages(inputField, location, filePath, errors);
+    return;
+  }
+  if (isObject(inputField)) {
+    if ("role" in inputField) {
+      validateMessages([inputField], location, filePath, errors);
+    }
+    return;
+  }
+  const label = location === "input" ? "suite-level 'input'" : "'input'";
+  errors.push({
+    severity: "error",
+    filePath,
+    location,
+    message: `Invalid ${label} field (must be a string, object, or array of messages)`
+  });
+}
 function validateMetadata(parsed, filePath, errors) {
   const name = parsed.name;
   if (name !== void 0) {
@@ -3500,8 +3657,15 @@ var GEMINI_SETTINGS = /* @__PURE__ */ new Set([
 ]);
 var CODEX_SETTINGS = /* @__PURE__ */ new Set([
   ...COMMON_SETTINGS,
+  "endpoint",
+  "base_url",
+  "api_key",
+  "api_format",
   "model",
   "model_reasoning_effort",
+  "model_verbosity",
+  "sandbox_mode",
+  "approval_policy",
   "executable",
   "command",
   "binary",
@@ -3533,7 +3697,9 @@ var COPILOT_SDK_SETTINGS = /* @__PURE__ */ new Set([
   "api_key",
   "bearer_token",
   "api_version",
-  "api_format"
+  "api_format",
+  "model_id",
+  "wire_model"
 ]);
 var COPILOT_CLI_SETTINGS = /* @__PURE__ */ new Set([
   ...COMMON_SETTINGS,
@@ -3554,7 +3720,9 @@ var COPILOT_CLI_SETTINGS = /* @__PURE__ */ new Set([
   "api_key",
   "bearer_token",
   "api_version",
-  "api_format"
+  "api_format",
+  "model_id",
+  "wire_model"
 ]);
 var VSCODE_SETTINGS = /* @__PURE__ */ new Set([
   ...COMMON_SETTINGS,
@@ -4093,31 +4261,114 @@ function validateProjects(errors, filePath, projects) {
     const projectRecord = project;
     validateRequiredString(errors, filePath, projectRecord.id, `${location}.id`);
     validateRequiredString(errors, filePath, projectRecord.name, `${location}.name`);
-    validateRequiredString(errors, filePath, projectRecord.path, `${location}.path`);
-    if (projectRecord.source !== void 0) {
-      errors.push({
-        severity: "error",
+    validateProjectRepoConfig(errors, filePath, projectRecord, location);
+    validateProjectResultsConfig(errors, filePath, projectRecord.results, `${location}.results`);
+  });
+}
+function addWarning(errors, filePath, location, message) {
+  errors.push({ severity: "warning", filePath, location, message });
+}
+function addError(errors, filePath, location, message) {
+  errors.push({ severity: "error", filePath, location, message });
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isGitRemoteUrlValue(value) {
+  return /^(https?:\/\/|ssh:\/\/|git@|file:\/\/).+/.test(value.trim());
+}
+function validateProjectRepoConfig(errors, filePath, projectRecord, location) {
+  if (projectRecord.source !== void 0) {
+    addError(
+      errors,
+      filePath,
+      `${location}.source`,
+      `Field '${location}.source' was removed. Move 'source.url' to '${location}.repo.url', move 'source.ref' to '${location}.repo.branch', and set '${location}.repo.path' to the local checkout path.`
+    );
+  }
+  if (projectRecord.repository !== void 0) {
+    addError(
+      errors,
+      filePath,
+      `${location}.repository`,
+      `Field '${location}.repository' was removed. Use '${location}.repo.url' with a Git remote URL instead.`
+    );
+  }
+  if (projectRecord.repo !== void 0) {
+    if (!isPlainObject(projectRecord.repo)) {
+      addError(
+        errors,
         filePath,
-        location: `${location}.source`,
-        message: `Field '${location}.source' was removed. Move 'source.url' to '${location}.repo_url' and move 'source.ref' to '${location}.ref'. Use a Git remote URL such as https://github.com/example/repo.git or git@github.com:example/repo.git.`
-      });
+        `${location}.repo`,
+        `Field '${location}.repo' must be an object with path, optional url, and optional branch.`
+      );
+      return;
     }
-    if (projectRecord.repository !== void 0) {
-      errors.push({
-        severity: "error",
+    for (const flatField of ["path", "repo_url", "ref"]) {
+      if (projectRecord[flatField] !== void 0) {
+        addError(
+          errors,
+          filePath,
+          `${location}.${flatField}`,
+          `Do not mix '${location}.${flatField}' with '${location}.repo'. Move source repo fields under '${location}.repo'.`
+        );
+      }
+    }
+    validateRequiredString(errors, filePath, projectRecord.repo.path, `${location}.repo.path`);
+    if (projectRecord.repo.url !== void 0) {
+      validateGitRemoteUrl(errors, filePath, projectRecord.repo.url, `${location}.repo.url`);
+    }
+    if (projectRecord.repo.branch !== void 0) {
+      validateRequiredString(
+        errors,
         filePath,
-        location: `${location}.repository`,
-        message: `Field '${location}.repository' was removed. Use '${location}.repo_url' with a Git remote URL instead.`
-      });
+        projectRecord.repo.branch,
+        `${location}.repo.branch`
+      );
     }
-    if (projectRecord.repo_url !== void 0) {
-      validateGitRemoteUrl(errors, filePath, projectRecord.repo_url, `${location}.repo_url`);
+    if (projectRecord.repo.ref !== void 0) {
+      addError(
+        errors,
+        filePath,
+        `${location}.repo.ref`,
+        `Field '${location}.repo.ref' is not supported. Use '${location}.repo.branch'.`
+      );
     }
-    if (projectRecord.ref !== void 0) {
-      validateRequiredString(errors, filePath, projectRecord.ref, `${location}.ref`);
+    if (projectRecord.repo.remote !== void 0) {
+      addError(
+        errors,
+        filePath,
+        `${location}.repo.remote`,
+        `Use '${location}.repo.url' for the source Git URL. '${location}.repo.remote' is only valid inside results repo config.`
+      );
     }
-    validateProjectResultsConfig(errors, filePath, projectRecord.results, `${location}.results`);
-  });
+    return;
+  }
+  validateRequiredString(errors, filePath, projectRecord.path, `${location}.path`);
+  addWarning(
+    errors,
+    filePath,
+    `${location}.path`,
+    `Field '${location}.path' is deprecated. Use '${location}.repo.path'. Existing flat project entries still load and are written back in nested form.`
+  );
+  if (projectRecord.repo_url !== void 0) {
+    validateGitRemoteUrl(errors, filePath, projectRecord.repo_url, `${location}.repo_url`);
+    addWarning(
+      errors,
+      filePath,
+      `${location}.repo_url`,
+      `Field '${location}.repo_url' is deprecated. Use '${location}.repo.url'.`
+    );
+  }
+  if (projectRecord.ref !== void 0) {
+    validateRequiredString(errors, filePath, projectRecord.ref, `${location}.ref`);
+    addWarning(
+      errors,
+      filePath,
+      `${location}.ref`,
+      `Field '${location}.ref' is deprecated. Use '${location}.repo.branch'.`
+    );
+  }
 }
 function validateRequiredString(errors, filePath, value, location) {
   if (typeof value !== "string" || value.trim().length === 0) {
@@ -4140,7 +4391,7 @@ function validateGitRemoteUrl(errors, filePath, value, location) {
     return;
   }
   const repoUrl = value.trim();
-  if (!/^(https?:\/\/|ssh:\/\/|git@|file:\/\/).+/.test(repoUrl)) {
+  if (!isGitRemoteUrlValue(repoUrl)) {
     errors.push({
       severity: "error",
       filePath,
@@ -4149,168 +4400,117 @@ function validateGitRemoteUrl(errors, filePath, value, location) {
     });
   }
 }
-function validateProjectResultsConfig(errors, filePath, rawResults, location) {
-  if (rawResults === void 0) {
+function validateResultsRepoBlock(errors, filePath, rawRepo, location) {
+  if (!isPlainObject(rawRepo)) {
+    addError(errors, filePath, location, `Field '${location}' must be an object`);
     return;
   }
-  if (typeof rawResults !== "object" || rawResults === null || Array.isArray(rawResults)) {
-    errors.push({
-      severity: "error",
+  const repoRecord = rawRepo;
+  const hasUrl = repoRecord.url !== void 0;
+  const hasRemote = repoRecord.remote !== void 0;
+  const hasPath = repoRecord.path !== void 0;
+  if (!hasRemote && !hasUrl && !hasPath) {
+    addError(errors, filePath, location, `Field '${location}' must set remote or path`);
+  }
+  if (hasRemote && hasUrl) {
+    addError(
+      errors,
       filePath,
       location,
-      message: `Field '${location}' must be an object`
-    });
-    return;
+      `Field '${location}' must set only one remote endpoint. Use '${location}.remote'.`
+    );
   }
-  const resultsRecord = rawResults;
-  const removedFields = {
-    mode: `Remove '${location}.mode'; project results use '${location}.repo_url' as the Git remote URL.`,
-    repo: `Field '${location}.repo' was removed. Use '${location}.repo_url' with a Git remote URL instead.`,
-    repository: `Field '${location}.repository' was removed. Use '${location}.repo_url' with a Git remote URL instead.`,
-    local_path: `Field '${location}.local_path' was removed. Use '${location}.path' for the local clone path instead.`,
-    auto_push: `Field '${location}.auto_push' was removed. Use '${location}.sync.auto_push' instead.`
-  };
-  for (const [field, message] of Object.entries(removedFields)) {
-    if (resultsRecord[field] !== void 0) {
-      errors.push({
-        severity: "error",
-        filePath,
-        location: `${location}.${field}`,
-        message
-      });
-    }
+  if (hasRemote) {
+    validateGitRemoteUrl(errors, filePath, repoRecord.remote, `${location}.remote`);
   }
-  const hasRepoUrl = resultsRecord.repo_url !== void 0;
-  const hasRepoPath = resultsRecord.repo_path !== void 0;
-  if (hasRepoUrl && hasRepoPath) {
-    errors.push({
-      severity: "error",
-      filePath,
-      location,
-      message: `Field '${location}' must set only one of repo_url or repo_path`
-    });
-  } else if (hasRepoUrl) {
-    validateGitRemoteUrl(errors, filePath, resultsRecord.repo_url, `${location}.repo_url`);
-  } else if (hasRepoPath) {
-    validateRequiredString(errors, filePath, resultsRecord.repo_path, `${location}.repo_path`);
-  } else {
-    errors.push({
-      severity: "error",
+  if (hasUrl) {
+    validateGitRemoteUrl(errors, filePath, repoRecord.url, `${location}.url`);
+    addWarning(
+      errors,
       filePath,
-      location,
-      message: `Field '${location}' must set repo_url or repo_path`
-    });
+      `${location}.url`,
+      `Field '${location}.url' is accepted for compatibility. Use '${location}.remote' for the Git remote URL.`
+    );
   }
-  if (resultsRecord.branch !== void 0 && (typeof resultsRecord.branch !== "string" || resultsRecord.branch.trim().length === 0)) {
-    errors.push({
-      severity: "error",
-      filePath,
-      location: `${location}.branch`,
-      message: `Field '${location}.branch' must be a non-empty string`
-    });
+  if (hasPath) {
+    validateRequiredString(errors, filePath, repoRecord.path, `${location}.path`);
   }
-  if (resultsRecord.remote !== void 0 && (typeof resultsRecord.remote !== "string" || resultsRecord.remote.trim().length === 0)) {
-    errors.push({
-      severity: "error",
+  if (repoRecord.branch !== void 0 && (typeof repoRecord.branch !== "string" || repoRecord.branch.trim().length === 0)) {
+    addError(
+      errors,
       filePath,
-      location: `${location}.remote`,
-      message: `Field '${location}.remote' must be a non-empty string`
-    });
+      `${location}.branch`,
+      `Field '${location}.branch' must be a non-empty string`
+    );
   }
-  if (resultsRecord.path !== void 0) {
-    if (typeof resultsRecord.path !== "string" || resultsRecord.path.trim().length === 0) {
-      errors.push({
-        severity: "error",
-        filePath,
-        location: `${location}.path`,
-        message: `Field '${location}.path' must be a non-empty string`
-      });
-    } else if (!isFilesystemPath(resultsRecord.path.trim())) {
-      errors.push({
-        severity: "error",
-        filePath,
-        location: `${location}.path`,
-        message: `'${location}.path' must be an absolute or home-relative filesystem path (e.g., ~/data/agentv-results).`
-      });
-    }
+}
+function validateResultsSyncAndBranchPrefix(errors, filePath, resultsRecord, location) {
+  if (resultsRecord.auto_push !== void 0 && typeof resultsRecord.auto_push !== "boolean") {
+    addError(
+      errors,
+      filePath,
+      `${location}.auto_push`,
+      `Field '${location}.auto_push' must be a boolean`
+    );
   }
   if (resultsRecord.sync !== void 0) {
     if (typeof resultsRecord.sync !== "object" || resultsRecord.sync === null || Array.isArray(resultsRecord.sync)) {
-      errors.push({
-        severity: "error",
-        filePath,
-        location: `${location}.sync`,
-        message: `Field '${location}.sync' must be an object`
-      });
+      addError(errors, filePath, `${location}.sync`, `Field '${location}.sync' must be an object`);
     } else {
       const syncRecord = resultsRecord.sync;
       if (syncRecord.auto_push !== void 0 && typeof syncRecord.auto_push !== "boolean") {
-        errors.push({
-          severity: "error",
+        addError(
+          errors,
           filePath,
-          location: `${location}.sync.auto_push`,
-          message: `Field '${location}.sync.auto_push' must be a boolean`
-        });
+          `${location}.sync.auto_push`,
+          `Field '${location}.sync.auto_push' must be a boolean`
+        );
       }
       if (syncRecord.require_push !== void 0 && typeof syncRecord.require_push !== "boolean") {
-        errors.push({
-          severity: "error",
+        addError(
+          errors,
           filePath,
-          location: `${location}.sync.require_push`,
-          message: `Field '${location}.sync.require_push' must be a boolean`
-        });
+          `${location}.sync.require_push`,
+          `Field '${location}.sync.require_push' must be a boolean`
+        );
+      }
+      if (syncRecord.push_conflict_policy !== void 0 && syncRecord.push_conflict_policy !== "block" && syncRecord.push_conflict_policy !== "backup_and_force_push") {
+        addError(
+          errors,
+          filePath,
+          `${location}.sync.push_conflict_policy`,
+          `Field '${location}.sync.push_conflict_policy' must be 'block' or 'backup_and_force_push'`
+        );
       }
     }
   }
   if (resultsRecord.branch_prefix !== void 0 && (typeof resultsRecord.branch_prefix !== "string" || resultsRecord.branch_prefix.trim().length === 0)) {
-    errors.push({
-      severity: "error",
+    addError(
+      errors,
       filePath,
-      location: `${location}.branch_prefix`,
-      message: `Field '${location}.branch_prefix' must be a non-empty string`
-    });
+      `${location}.branch_prefix`,
+      `Field '${location}.branch_prefix' must be a non-empty string`
+    );
   }
 }
-function validateResultsConfig(errors, filePath, rawResults, location) {
-  if (rawResults === void 0) {
-    return;
-  }
-  if (typeof rawResults !== "object" || rawResults === null || Array.isArray(rawResults)) {
-    errors.push({
-      severity: "error",
-      filePath,
-      location,
-      message: `Field '${location}' must be an object`
-    });
-    return;
-  }
-  const resultsRecord = rawResults;
-  if (resultsRecord.mode !== void 0 && resultsRecord.mode !== "github") {
-    errors.push({
-      severity: "error",
-      filePath,
-      location: `${location}.mode`,
-      message: `Field '${location}.mode' must be 'github'`
-    });
-  }
-  const hasLegacyRepo = resultsRecord.repo !== void 0;
+function validateFlatResultsRepoConfig(errors, filePath, resultsRecord, location, options) {
+  const hasLegacyRepo = typeof resultsRecord.repo === "string";
   const hasRepoUrl = resultsRecord.repo_url !== void 0;
   const hasRepoPath = resultsRecord.repo_path !== void 0;
-  const sourceCount = [hasLegacyRepo, hasRepoUrl, hasRepoPath].filter(Boolean).length;
+  const sourceCount = [
+    options.allowLegacyRepoString && hasLegacyRepo,
+    hasRepoUrl,
+    hasRepoPath
+  ].filter(Boolean).length;
   if (sourceCount === 0) {
-    errors.push({
-      severity: "error",
-      filePath,
-      location,
-      message: `Field '${location}' must set repo_url/repo or repo_path`
-    });
+    addError(errors, filePath, location, `Field '${location}' must set repo.remote or repo.path`);
   } else if (sourceCount > 1) {
-    errors.push({
-      severity: "error",
+    addError(
+      errors,
       filePath,
       location,
-      message: `Field '${location}' must set only one of repo_url/repo or repo_path`
-    });
+      `Field '${location}' must set only one results repo source. Use '${location}.repo.remote' for a managed clone or '${location}.repo.path' for an existing local checkout.`
+    );
   } else if (hasLegacyRepo) {
     validateRequiredString(errors, filePath, resultsRecord.repo, `${location}.repo`);
   } else if (hasRepoUrl) {
@@ -4319,85 +4519,151 @@ function validateResultsConfig(errors, filePath, rawResults, location) {
     validateRequiredString(errors, filePath, resultsRecord.repo_path, `${location}.repo_path`);
   }
   if (resultsRecord.branch !== void 0 && (typeof resultsRecord.branch !== "string" || resultsRecord.branch.trim().length === 0)) {
-    errors.push({
-      severity: "error",
+    addError(
+      errors,
       filePath,
-      location: `${location}.branch`,
-      message: `Field '${location}.branch' must be a non-empty string`
-    });
+      `${location}.branch`,
+      `Field '${location}.branch' must be a non-empty string`
+    );
   }
   if (resultsRecord.remote !== void 0 && (typeof resultsRecord.remote !== "string" || resultsRecord.remote.trim().length === 0)) {
-    errors.push({
-      severity: "error",
+    addError(
+      errors,
       filePath,
-      location: `${location}.remote`,
-      message: `Field '${location}.remote' must be a non-empty string`
-    });
+      `${location}.remote`,
+      `Field '${location}.remote' must be a non-empty string`
+    );
   }
   if (resultsRecord.path !== void 0) {
     if (typeof resultsRecord.path !== "string" || resultsRecord.path.trim().length === 0) {
-      errors.push({
-        severity: "error",
+      addError(
+        errors,
         filePath,
-        location: `${location}.path`,
-        message: `Field '${location}.path' must be a non-empty string`
-      });
+        `${location}.path`,
+        `Field '${location}.path' must be a non-empty string`
+      );
     } else {
       const p = resultsRecord.path.trim();
       if (!isFilesystemPath(p)) {
-        errors.push({
-          severity: "error",
+        addError(
+          errors,
           filePath,
-          location: `${location}.path`,
-          message: `'${location}.path' must be an absolute or home-relative filesystem path (e.g., ~/data/agentv-results). Found: '${p}'. Remove 'path' to use the default.`
-        });
+          `${location}.path`,
+          `'${location}.path' must be an absolute or home-relative filesystem path (e.g., ~/data/agentv-results). Found: '${p}'. Remove 'path' to use the default.`
+        );
       }
     }
   }
-  if (resultsRecord.auto_push !== void 0 && typeof resultsRecord.auto_push !== "boolean") {
-    errors.push({
-      severity: "error",
+}
+function warnFlatResultsMigration(errors, filePath, resultsRecord, location) {
+  const migrations = {
+    repo: `${location}.repo.remote`,
+    repo_url: `${location}.repo.remote`,
+    repo_path: `${location}.repo.path`,
+    branch: `${location}.repo.branch`,
+    path: `${location}.repo.path`,
+    auto_push: `${location}.sync.auto_push`,
+    mode: "(remove this field)"
+  };
+  for (const [field, replacement] of Object.entries(migrations)) {
+    if (resultsRecord[field] !== void 0) {
+      addWarning(
+        errors,
+        filePath,
+        `${location}.${field}`,
+        `Field '${location}.${field}' is deprecated. Use '${replacement}' in the nested results repo schema.`
+      );
+    }
+  }
+  if (resultsRecord.remote !== void 0) {
+    addWarning(
+      errors,
       filePath,
-      location: `${location}.auto_push`,
-      message: `Field '${location}.auto_push' must be a boolean`
-    });
+      `${location}.remote`,
+      `Field '${location}.remote' is a legacy local Git remote-name override. Prefer omitting it; nested '${location}.repo.remote' is the portable Git remote URL and AgentV manages local aliases automatically.`
+    );
   }
-  if (resultsRecord.sync !== void 0) {
-    if (typeof resultsRecord.sync !== "object" || resultsRecord.sync === null || Array.isArray(resultsRecord.sync)) {
-      errors.push({
-        severity: "error",
+}
+function validateResultsConfigBody(errors, filePath, rawResults, location, options) {
+  if (rawResults === void 0) {
+    return;
+  }
+  if (!isPlainObject(rawResults)) {
+    addError(errors, filePath, location, `Field '${location}' must be an object`);
+    return;
+  }
+  const resultsRecord = rawResults;
+  if (resultsRecord.mode !== void 0) {
+    if (options.projectScoped) {
+      addError(
+        errors,
         filePath,
-        location: `${location}.sync`,
-        message: `Field '${location}.sync' must be an object`
-      });
+        `${location}.mode`,
+        `Remove '${location}.mode'; project results use '${location}.repo.remote' or '${location}.repo.path'.`
+      );
+    } else if (resultsRecord.mode !== "github") {
+      addError(errors, filePath, `${location}.mode`, `Field '${location}.mode' must be 'github'`);
+    }
+  }
+  for (const [field, message] of Object.entries({
+    repository: `Field '${location}.repository' was removed. Use '${location}.repo.remote' with a Git remote URL instead.`,
+    local_path: `Field '${location}.local_path' was removed. Use '${location}.repo.path' for the local clone path instead.`
+  })) {
+    if (resultsRecord[field] !== void 0) {
+      addError(errors, filePath, `${location}.${field}`, message);
+    }
+  }
+  if (options.projectScoped && resultsRecord.auto_push !== void 0) {
+    addError(
+      errors,
+      filePath,
+      `${location}.auto_push`,
+      `Field '${location}.auto_push' was removed. Use '${location}.sync.auto_push' instead.`
+    );
+  }
+  const hasNestedRepo = isPlainObject(resultsRecord.repo);
+  if (resultsRecord.repo !== void 0 && !hasNestedRepo) {
+    if (typeof resultsRecord.repo === "string" && options.allowLegacyRepoString) {
     } else {
-      const syncRecord = resultsRecord.sync;
-      if (syncRecord.auto_push !== void 0 && typeof syncRecord.auto_push !== "boolean") {
-        errors.push({
-          severity: "error",
-          filePath,
-          location: `${location}.sync.auto_push`,
-          message: `Field '${location}.sync.auto_push' must be a boolean`
-        });
-      }
-      if (syncRecord.require_push !== void 0 && typeof syncRecord.require_push !== "boolean") {
-        errors.push({
-          severity: "error",
+      addError(
+        errors,
+        filePath,
+        `${location}.repo`,
+        `Field '${location}.repo' must be an object. Use '${location}.repo.remote' for a Git remote URL or '${location}.repo.path' for an existing local checkout.`
+      );
+    }
+  }
+  if (hasNestedRepo) {
+    for (const flatField of ["repo_url", "repo_path", "branch", "remote", "path"]) {
+      if (resultsRecord[flatField] !== void 0) {
+        addError(
+          errors,
           filePath,
-          location: `${location}.sync.require_push`,
-          message: `Field '${location}.sync.require_push' must be a boolean`
-        });
+          `${location}.${flatField}`,
+          `Do not mix '${location}.${flatField}' with '${location}.repo'. Move results repo fields under '${location}.repo'.`
+        );
       }
     }
-  }
-  if (resultsRecord.branch_prefix !== void 0 && (typeof resultsRecord.branch_prefix !== "string" || resultsRecord.branch_prefix.trim().length === 0)) {
-    errors.push({
-      severity: "error",
-      filePath,
-      location: `${location}.branch_prefix`,
-      message: `Field '${location}.branch_prefix' must be a non-empty string`
+    validateResultsRepoBlock(errors, filePath, resultsRecord.repo, `${location}.repo`);
+  } else {
+    validateFlatResultsRepoConfig(errors, filePath, resultsRecord, location, {
+      allowLegacyRepoString: options.allowLegacyRepoString
     });
+    warnFlatResultsMigration(errors, filePath, resultsRecord, location);
   }
+  validateResultsSyncAndBranchPrefix(errors, filePath, resultsRecord, location);
+}
+function validateProjectResultsConfig(errors, filePath, rawResults, location) {
+  validateResultsConfigBody(errors, filePath, rawResults, location, {
+    allowLegacyRepoString: false,
+    projectScoped: true
+  });
+}
+function validateResultsConfig(errors, filePath, rawResults, location) {
+  validateResultsConfigBody(errors, filePath, rawResults, location, {
+    allowLegacyRepoString: true,
+    projectScoped: false
+  });
 }
 function isFilesystemPath(p) {
   return p.startsWith("/") || p.startsWith("~/") || p.startsWith("~\\") || p === "~" || /^[A-Za-z]:[/\\]/.test(p);
@@ -5110,6 +5376,12 @@ function normalizeOutputMessages(cliValue) {
 function trimOutputMessages(output, _outputMessages) {
   return output;
 }
+function prepareResultForJsonl(result, options) {
+  return {
+    ...result,
+    output: trimOutputMessages(result.output, options.outputMessages)
+  };
+}
 function normalizeOptions(rawOptions, config, yamlExecution) {
   const cliWorkers = normalizeOptionalNumber(rawOptions.workers);
   const configWorkers = config?.execution?.workers;
@@ -5240,8 +5512,8 @@ async function ensureFileExists(filePath, description) {
     throw new Error(`${description} not found: ${filePath}`);
   }
 }
-function buildDefaultOutputPathForExperiment(cwd, experiment) {
-  const runDir = buildDefaultRunDir(cwd, experiment);
+function buildDefaultOutputPathForExperiment(cwd, experiment, runDirName) {
+  const runDir = buildDefaultRunDirFromName(cwd, experiment, runDirName);
   mkdirSync2(runDir, { recursive: true });
   return path14.join(runDir, "index.jsonl");
 }
@@ -5597,11 +5869,7 @@ async function runSingleEvalFile(params) {
       streamingObserver?.completeFromResult?.(result);
       streamingObserver?.finalizeEvalCase(result.score, result.error);
       const resultWithMetadata = withSourceMetadata(result, testFilePath, options);
-      const trimmedOutput = trimOutputMessages(resultWithMetadata.output, options.outputMessages);
-      const trimmedResult = {
-        ...resultWithMetadata,
-        output: trimmedOutput
-      };
+      const trimmedResult = prepareResultForJsonl(resultWithMetadata, options);
       await outputWriter.append(trimmedResult);
       if (otelExporter && !streamingObserver) {
         try {
@@ -5649,9 +5917,6 @@ async function runSingleEvalFile(params) {
 }
 async function runEvalCommand(input) {
   const cwd = process.cwd();
-  if (!process.env.AGENTV_RUN_TIMESTAMP) {
-    process.env.AGENTV_RUN_TIMESTAMP = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").replace(/\./g, "-");
-  }
   let config = null;
   try {
     config = await loadTsConfig(cwd);
@@ -5770,19 +6035,24 @@ async function runEvalCommand(input) {
   const explicitDir = options.outputDir;
   let runDir;
   let outputPath;
+  const runDirName = process.env.AGENTV_RUN_TIMESTAMP?.trim() || createRunDirName();
   if (explicitDir) {
     runDir = path14.resolve(explicitDir);
     mkdirSync2(runDir, { recursive: true });
     outputPath = path14.join(runDir, "index.jsonl");
   } else {
-    outputPath = buildDefaultOutputPathForExperiment(cwd, options.experiment);
+    outputPath = buildDefaultOutputPathForExperiment(cwd, options.experiment, runDirName);
     runDir = path14.dirname(outputPath);
   }
+  if (!process.env.AGENTV_RUN_TIMESTAMP) {
+    process.env.AGENTV_RUN_TIMESTAMP = path14.basename(runDir);
+  }
+  process.env.AGENTV_RUN_DIR = runDir;
   let otelExporter = null;
   const useFileExport = !!options.otelFile;
   if (options.exportOtel || useFileExport) {
     try {
-      const { OtelTraceExporter } = await import("./dist-VQWTETNY.js");
+      const { OtelTraceExporter } = await import("./dist-L4YCQOQ6.js");
       let endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
       let headers = {};
       let resourceAttributes = {};
@@ -5987,7 +6257,7 @@ async function runEvalCommand(input) {
   const activeTestFiles = resolvedTestFiles.filter((f) => fileMetadata.has(f));
   let transcriptProviderFactory;
   if (options.transcript) {
-    const { TranscriptProvider } = await import("./dist-VQWTETNY.js");
+    const { TranscriptProvider } = await import("./dist-L4YCQOQ6.js");
     const transcriptProvider = await TranscriptProvider.fromFile(options.transcript);
     const totalTests = [...fileMetadata.values()].reduce(
       (sum, meta) => sum + meta.testCases.length,
@@ -6211,7 +6481,7 @@ ${formatRequiredVersionFailureNote(requiredVersionCheck)}`);
       );
       const taskBundleTargets = buildTaskBundleTargetSelections(activeTestFiles, fileMetadata);
       if (isResumeAppend) {
-        const { writePerTestArtifacts } = await import("./artifact-writer-7PXSB6LM.js");
+        const { writePerTestArtifacts } = await import("./artifact-writer-72MQQELS.js");
         await writePerTestArtifacts(allResults, runDir, {
           experiment: normalizeExperimentName(options.experiment),
           cwd,
@@ -6394,9 +6664,13 @@ export {
   findRepoRoot,
   package_default,
   RESULT_INDEX_FILENAME,
+  isReservedResultsNamespace,
+  normalizeExperimentName,
   createRunDirName,
+  buildDefaultRunDirFromName,
   buildDefaultRunDir,
   resolveRunManifestPath,
+  relativeRunPathFromCwd,
   parseResultManifest,
   resolveResultSourcePath,
   loadManifestResults,
@@ -6430,9 +6704,13 @@ export {
   formatCost,
   formatSize,
   formatScore,
+  TagRevisionConflictError,
+  assertExpectedTagRevision,
+  materializeRunState,
   readRunTags,
   writeRunTags,
-  deleteRunTags,
+  normalizeTags,
+  loadNormalizedResultsConfig,
   isRemoteRunId,
   getRemoteResultsStatus,
   syncRemoteResults,
@@ -6450,4 +6728,4 @@ export {
   getCategories,
   filterByCategory
 };
-//# sourceMappingURL=chunk-N6U3GXMF.js.map
+//# sourceMappingURL=chunk-CXHYTYHU.js.map