From c63d1c8397a7b990bfdabc2d25fac29d7d828234 Mon Sep 17 00:00:00 2001
From: Christopher Tso <christso@gmail.com>
Date: Fri, 3 Jul 2026 13:45:17 +0200
Subject: [PATCH 1/3] fix(results): publish runs at results branch root

---
 .../src/lib/project-sync-status.test.ts       |   8 +-
 apps/dashboard/src/lib/project-sync-status.ts |  12 +-
 .../content/docs/docs/next/tools/results.mdx  |   2 +-
 .../docs/docs/v4.42.4/tools/results.mdx       |  18 +-
 .../src/evaluation/results-repo-cache.test.ts |  18 +-
 packages/core/src/evaluation/results-repo.ts  | 299 +++----
 .../core/test/evaluation/results-repo.test.ts | 768 +++---------------
 7 files changed, 228 insertions(+), 897 deletions(-)

diff --git a/apps/dashboard/src/lib/project-sync-status.test.ts b/apps/dashboard/src/lib/project-sync-status.test.ts
index d152ccc29..6975bff52 100644
--- a/apps/dashboard/src/lib/project-sync-status.test.ts
+++ b/apps/dashboard/src/lib/project-sync-status.test.ts
@@ -18,19 +18,19 @@ describe('getProjectSyncView', () => {
     });
   });
 
-  it('surfaces dirty metadata as syncable without reset language', () => {
+  it('surfaces dirty result artifacts as syncable without reset language', () => {
     const view = getProjectSyncView({
       configured: true,
       available: true,
       sync_status: 'dirty',
-      dirty_paths: ['metadata/runs/demo/tags.json'],
+      dirty_paths: ['demo-run/summary.json'],
       auto_push: false,
     });
 
     expect(view).toMatchObject({
       state: 'dirty',
       label: 'Dirty',
-      actionLabel: 'Sync Metadata',
+      actionLabel: 'Sync Results',
       canSync: true,
     });
     expect(view.nextAction).toContain('no reset');
@@ -182,7 +182,7 @@ describe('buildProjectSyncFeedback', () => {
 
     expect(feedback.kind).toBe('success');
     expect(feedback.message).toContain(
-      'Sync completed: committed pending metadata, pulled remote results, pushed local results.',
+      'Sync completed: committed pending results, pulled remote results, pushed local results.',
     );
   });
 
diff --git a/apps/dashboard/src/lib/project-sync-status.ts b/apps/dashboard/src/lib/project-sync-status.ts
index e6e45c229..467be30e3 100644
--- a/apps/dashboard/src/lib/project-sync-status.ts
+++ b/apps/dashboard/src/lib/project-sync-status.ts
@@ -218,13 +218,13 @@ export function getProjectSyncView(
     return {
       state: 'dirty',
       label: 'Dirty',
-      actionLabel: 'Sync Metadata',
+      actionLabel: 'Sync Results',
       tone: 'warn',
-      summary: status.block_reason ?? 'Local result metadata has pending edits.',
+      summary: status.block_reason ?? 'Local result artifacts have pending edits.',
       nextAction:
         status.auto_push === true
-          ? 'Sync Project will commit safe result metadata changes before syncing.'
-          : 'Review or commit the pending result metadata; no reset will be performed.',
+          ? 'Sync Project will commit safe result artifact changes before syncing.'
+          : 'Review or commit the pending result artifacts; no reset will be performed.',
       canSync: true,
     };
   }
@@ -261,7 +261,7 @@ export function getProjectSyncView(
     label: 'Clean',
     actionLabel: 'Sync Project',
     tone: 'good',
-    summary: 'Local and remote result metadata are in sync.',
+    summary: 'Local and remote results are in sync.',
     canSync: true,
   };
 }
@@ -332,7 +332,7 @@ export function buildProjectSyncFeedback(status: RemoteStatusResponse): {
   }
 
   const actions = [
-    status.commit_created ? 'committed pending metadata' : undefined,
+    status.commit_created ? 'committed pending results' : undefined,
     status.pull_performed ? 'pulled remote results' : undefined,
     status.auto_merged_remote ? 'Merged remote (auto)' : undefined,
     status.push_performed ? 'pushed local results' : undefined,
diff --git a/apps/web/src/content/docs/docs/next/tools/results.mdx b/apps/web/src/content/docs/docs/next/tools/results.mdx
index e60ad51e1..64e04be8b 100644
--- a/apps/web/src/content/docs/docs/next/tools/results.mdx
+++ b/apps/web/src/content/docs/docs/next/tools/results.mdx
@@ -255,7 +255,7 @@ The CLI contract is deliberately narrow: `agentv results` manages local result a
 
 Use these supported remote workflows instead:
 
-- **Automatic publishing:** configure `projects[].results` or top-level `results`; new `agentv eval` and `agentv pipeline bench` runs publish completed artifacts after the run completes. Use `results.repo` with `results.path` pointing at the source checkout and `results.branch: agentv/results/v1` to store primary result records on a dedicated branch of the source repo. AgentV never adds or rewrites remotes in an existing checkout; that checkout's `origin` must already point at the repository you want to fetch and push. AgentV reserves `agentv/results/v1` for primary results and `agentv/artifacts/v1` for heavy artifact payloads. When `index.jsonl` rows point trace or transcript payloads at `agentv/artifacts/v1`, automatic publishing stores those bytes on that artifact branch in the same remote and publishes pointer keys such as `runs/<run_id>/<pointer.path>`. The configured results branch remains the metadata/control plane (`index.jsonl`, `summary.json`, tags, and pointers) instead of duplicating canonical trace/transcript payload bodies. Local pre-publish run workspaces can still contain those files beside the manifest so local tools keep working. Mutable run tags are stored as `tags.json` with a `tag_revision`; there is no tag event log in the normal results layout. `results.path` without `results.repo` means an existing local Git checkout, distinct from `workspace.repos[].repo`, which is a portable repository identity. Set `auto_push: true` to push after publish. In CI, use `agentv eval run --results-require-push` when push failures should fail that invocation after local artifacts are written. Non-fast-forward result branch pushes never force-push: AgentV auto-merges concurrent remote writes with artifact-aware Git merge drivers (a union driver for the append-only `index.jsonl`, a JSON-union driver for tag overlays) and pushes the merge as a fast-forward, and routes a genuine overlay conflict to a timestamped `agentv/results-sync/...` branch plus a GitHub compare/PR link for a human merge. While an eval is still running, [WIP checkpoints](/docs/tools/wip-checkpoints/) can keep partial run output durable on `agentv/wip/...` branches when auto-push is enabled.
+- **Automatic publishing:** configure `projects[].results` or top-level `results`; new `agentv eval` and `agentv pipeline bench` runs publish completed artifacts after the run completes. Use `results.repo` with `results.path` pointing at the source checkout and `results.branch: agentv/results/v1` to store primary result records on a dedicated branch of the source repo. AgentV never adds or rewrites remotes in an existing checkout; that checkout's `origin` must already point at the repository you want to fetch and push. AgentV reserves `agentv/results/v1` for primary results and `agentv/artifacts/v1` for heavy artifact payloads. The results branch stores run bundles at `<run_id>/` with `summary.json` at the run root and machine files such as the per-run JSONL index under `<run_id>/.internal/`; cross-run derived catalogs live under `.indexes/`. When index rows point trace or transcript payloads at `agentv/artifacts/v1`, automatic publishing stores those bytes on the artifact branch in the same remote and publishes pointer keys such as `<run_id>/<pointer.path>`. Run tags are read from `summary.json` and index rows; there is no mutable `tags.json` overlay in the published results layout. `results.path` without `results.repo` means an existing local Git checkout, distinct from `workspace.repos[].repo`, which is a portable repository identity. Set `auto_push: true` to push after publish. In CI, use `agentv eval run --results-require-push` when push failures should fail that invocation after local artifacts are written. Non-fast-forward result branch pushes never force-push: AgentV auto-merges concurrent remote writes with artifact-aware Git merge rules for append-only JSONL indexes and pushes the merge as a fast-forward, routing genuine content conflicts to a timestamped `agentv/results-sync/...` branch plus a GitHub compare/PR link for a human merge. While an eval is still running, [WIP checkpoints](/docs/tools/wip-checkpoints/) can keep partial run output durable on `agentv/wip/...` branches when auto-push is enabled.
 - **Manual Dashboard sync:** run `agentv dashboard`, open the project, and use **Sync Project**.
 - **Manual API sync:** while Dashboard is running, call `GET /api/projects/:projectId/remote/status` or `POST /api/projects/:projectId/remote/sync` for project-scoped automation. Single-project sessions also expose `GET /api/remote/status` and `POST /api/remote/sync`.
 - **Git escape hatch:** for advanced recovery, inspect or repair the configured `projects[].results.path` clone with `git` directly, then sync again.
diff --git a/apps/web/src/content/docs/docs/v4.42.4/tools/results.mdx b/apps/web/src/content/docs/docs/v4.42.4/tools/results.mdx
index 5daf29f01..1c12cb71f 100644
--- a/apps/web/src/content/docs/docs/v4.42.4/tools/results.mdx
+++ b/apps/web/src/content/docs/docs/v4.42.4/tools/results.mdx
@@ -43,10 +43,10 @@ Examples:
 
 ```bash
 # Generate report.html next to the run manifest
-agentv results report .agentv/results/runs/2026-03-14T10-32-00_claude
+agentv results report .agentv/results/2026-03-14T10-32-00_claude
 
 # Use an explicit output path
-agentv results report .agentv/results/runs/2026-03-14T10-32-00_claude/index.jsonl \
+agentv results report .agentv/results/2026-03-14T10-32-00_claude/index.jsonl \
   --out ./reports/human-review.html
 ```
 
@@ -65,17 +65,17 @@ One minimal publication workflow is:
 
 ```bash
 # 1. Run an eval and sync or copy the run workspace into your public results repo.
-agentv eval evals/demo.eval.yaml --output .agentv/results/runs/demo-live
+agentv eval evals/demo.eval.yaml --output .agentv/results/demo-live
 
 # 2. In the public results repo, render the report into the Pages source directory.
-agentv results report .agentv/results/runs/demo-live --out docs/index.html
+agentv results report .agentv/results/demo-live --out docs/index.html
 
 # 3. Review the generated HTML before publishing.
 grep -RInE 'sk-[A-Za-z0-9]|Bearer |localhost|127\.0\.0\.1|/home/|/Users/|/tmp/' docs/index.html
 
 # 4. Commit the run artifacts and docs/index.html, then enable GitHub Pages
 #    for the repository's docs/ directory or the branch used for Pages.
-git add .agentv/results/runs/demo-live docs/index.html README.md
+git add .agentv/results/demo-live docs/index.html README.md
 git commit -m "docs(results): publish static AgentV report"
 git push
 ```
@@ -116,10 +116,10 @@ Duplicate policy is explicit:
 For lightweight terminal workflows:
 
 ```bash
-agentv results summary .agentv/results/runs/<timestamp>
-agentv results failures .agentv/results/runs/<timestamp>
-agentv results show .agentv/results/runs/<timestamp> --test-id my-case
-agentv results validate .agentv/results/runs/<timestamp>
+agentv results summary .agentv/results/<timestamp>
+agentv results failures .agentv/results/<timestamp>
+agentv results show .agentv/results/<timestamp> --test-id my-case
+agentv results validate .agentv/results/<timestamp>
 ```
 
 For a review-centric workflow built around these artifacts, see [Human Review Checkpoint](/docs/v4.42.4/guides/human-review/).
diff --git a/packages/core/src/evaluation/results-repo-cache.test.ts b/packages/core/src/evaluation/results-repo-cache.test.ts
index 38dce44c0..f41c865bf 100644
--- a/packages/core/src/evaluation/results-repo-cache.test.ts
+++ b/packages/core/src/evaluation/results-repo-cache.test.ts
@@ -34,10 +34,12 @@ function writeRun(
   score: number,
   executionStatus = 'ok',
 ): void {
-  const runDir = path.join(repoDir, 'runs', timestamp);
+  const runDir = path.join(repoDir, timestamp);
+  const internalDir = path.join(runDir, '.internal');
   mkdirSync(runDir, { recursive: true });
+  mkdirSync(internalDir, { recursive: true });
   writeFileSync(
-    path.join(runDir, 'index.jsonl'),
+    path.join(internalDir, 'index.jsonl'),
     `${JSON.stringify({
       timestamp,
       test_id: `${experiment}-case`,
@@ -51,7 +53,7 @@ function writeRun(
     path.join(runDir, 'summary.json'),
     `${JSON.stringify(
       {
-        manifest_path: 'index.jsonl',
+        index_path: '.internal/index.jsonl',
         metadata: {
           display_name: `${experiment} ${timestamp}`,
           experiment,
@@ -82,7 +84,7 @@ function createResultsRepo(tempRoot: string): string {
   git(repoDir, ['checkout', '--orphan', RESULTS_REF]);
   rmSync(path.join(repoDir, 'README.md'), { force: true });
   writeRun(repoDir, 'default', '2026-06-28T00-00-00-000Z', 1);
-  git(repoDir, ['add', 'runs']);
+  git(repoDir, ['add', '.']);
   git(repoDir, ['commit', '-m', 'add first run']);
   return repoDir;
 }
@@ -114,7 +116,7 @@ describe('git results filesystem index cache', () => {
     const runs = await listGitRunsCached(repoDir, RESULTS_REF);
     expect(runs).toHaveLength(1);
     expect(runs[0]?.run_id).toBe('2026-06-28T00-00-00-000Z');
-    expect(runs[0]?.summary_path).toBe('runs/2026-06-28T00-00-00-000Z/summary.json');
+    expect(runs[0]?.summary_path).toBe('2026-06-28T00-00-00-000Z/summary.json');
 
     const cacheFile = resolveGitResultsIndexCacheFile({
       repoDir,
@@ -146,7 +148,7 @@ describe('git results filesystem index cache', () => {
               run_id: 'sentinel',
               experiment: 'default',
               timestamp: '2026-06-28T01-00-00-000Z',
-              manifest_path: 'runs/sentinel/index.jsonl',
+              manifest_path: 'sentinel/.internal/index.jsonl',
               display_name: 'from cache',
               test_count: 1,
               avg_score: 0.5,
@@ -172,7 +174,7 @@ describe('git results filesystem index cache', () => {
     const firstCommit = await resolveGitRunsRefCommit(repoDir, RESULTS_REF);
 
     writeRun(repoDir, 'experiment-a', '2026-06-28T02-00-00-000Z', 0.25);
-    git(repoDir, ['add', 'runs']);
+    git(repoDir, ['add', '.']);
     git(repoDir, ['commit', '-m', 'add second run']);
     const secondCommit = await resolveGitRunsRefCommit(repoDir, RESULTS_REF);
 
@@ -211,7 +213,7 @@ describe('git results filesystem index cache', () => {
   it('preserves execution error counts for remote-only list metadata', async () => {
     const repoDir = createResultsRepo(tempRoot);
     writeRun(repoDir, 'error-experiment', '2026-06-28T03-00-00-000Z', 0, 'execution_error');
-    git(repoDir, ['add', 'runs']);
+    git(repoDir, ['add', '.']);
     git(repoDir, ['commit', '-m', 'add execution error run']);
 
     const runs = await listGitRunsCached(repoDir, RESULTS_REF);
diff --git a/packages/core/src/evaluation/results-repo.ts b/packages/core/src/evaluation/results-repo.ts
index 5c77d8024..e9e0fbb6a 100644
--- a/packages/core/src/evaluation/results-repo.ts
+++ b/packages/core/src/evaluation/results-repo.ts
@@ -30,16 +30,16 @@ const execFileAsync = promisify(execFile);
 // write runs here. This is NOT the on-branch layout — see RESULTS_REPO_RUNS_DIR.
 const RESULTS_REPO_RESULTS_DIR = '.agentv/results';
 // On-branch / results-repo-clone storage layout. The results branch (e.g.
-// agentv/results/v1) already namespaces results, so runs are stored flat at
-// runs/<run_id>/ and the editable tag overlays at metadata/runs/<run_id>/ —
-// no redundant `.agentv/results/` prefix.
-const RESULTS_REPO_RUNS_DIR = 'runs';
-const RESULTS_REPO_METADATA_DIR = 'metadata';
+// agentv/results/v1) already namespaces results, so run bundles are stored at
+// the branch root as <run_id>/ with ADR-0017 internals preserved.
+const RESULTS_REPO_RUNS_DIR = '.';
+const RESULTS_REPO_INDEXES_DIR = '.indexes';
+const RESULTS_REPO_CACHE_DIR = '.cache';
 // Top-level directories AgentV owns on the results branch. The auto-sync
 // dirty-commit path stages only these so it never touches unrelated repo files.
-const RESULTS_REPO_TRACKED_DIRS = [RESULTS_REPO_RUNS_DIR, RESULTS_REPO_METADATA_DIR] as const;
+const RESULTS_REPO_TRACKED_DOT_DIRS = [RESULTS_REPO_INDEXES_DIR, RESULTS_REPO_CACHE_DIR] as const;
 const GIT_RESULTS_INDEX_CACHE_SCHEMA_VERSION = 'agentv.git_results_index_cache.v1';
-const GIT_RESULTS_INDEX_LAYOUT_VERSION = 'agentv.results_repo_runs.v1';
+const GIT_RESULTS_INDEX_LAYOUT_VERSION = 'agentv.results_repo_branch_root.v1';
 const FALLBACK_RESULTS_REPO_COMMIT_EMAIL = 'agentv@results-repo';
 const FALLBACK_RESULTS_REPO_COMMIT_NAME = 'AgentV Results';
 const GIT_COMMIT_IDENTITY_ENV_KEYS = [
@@ -68,135 +68,15 @@ const RESULTS_REPO_GENESIS_MESSAGE = 'chore(results): initialize AgentV results
 const RESULTS_REPO_GENESIS_DATE = '@0 +0000';
 const RESULT_INDEX_FILENAME = 'index.jsonl';
 
-// Artifact-aware merge config for the AgentV-owned results checkout. These two
-// pieces let `git merge` reconcile concurrent result writes automatically so
-// results sync never has to force-push (see resolveResultBranchPushConflict):
-//   - `.gitattributes` (committed on the results branch) maps the append-only
-//     run index to git's stock `union` driver and the editable JSON overlay to
-//     our `agentv-json` driver.
-//   - `merge.agentv-json.driver` (registered once in the checkout's local git
-//     config) points at a tiny 3-way JSON set/field union script.
-// Run bundles under runs/<run_id>/** are uniquely pathed, so a 3-way merge
-// never conflicts on them and they need no attribute.
+// Artifact-aware merge config for the AgentV-owned results checkout. Concurrent
+// writers append to rebuildable cross-run JSONL catalogs and each run's
+// per-run JSONL index; git's stock `union` driver can reconcile those appends.
+// Run bundles under <run_id>/** are uniquely pathed, so a 3-way merge usually
+// never conflicts on them.
 const RESULTS_REPO_GITATTRIBUTES_FILE = '.gitattributes';
 const RESULTS_REPO_GITATTRIBUTES_CONTENT = `# Managed by AgentV. Artifact-aware merge so results sync never force-pushes.
-# Append-only run manifests: union concurrent appends (lines are orthogonal).
-index.jsonl merge=union
-# Editable run overlay (tags): 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
-`;
-const RESULTS_JSON_MERGE_DRIVER_NAME = 'agentv-json';
-// Materialized into the results checkout's git dir and invoked by git as
-// `node <script> %O %A %B %P`. Kept dependency-free and self-describing so it
-// runs under any Node without bundling. To extend the overlay merge, add cases
-// to merge3 below (e.g. new regenerable bookkeeping fields).
-const 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).
-// 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);
+${RESULTS_REPO_INDEXES_DIR}/*.jsonl merge=union
+*/.internal/index.jsonl merge=union
 `;
 
 export interface ResultsRepoLocalPaths {
@@ -801,12 +681,10 @@ async function resolveGitTopLevel(repoDir: string): Promise<string> {
   return stdout.trim() || repoDir;
 }
 
-// Register the artifact-aware `agentv-json` merge driver in the AgentV-owned
-// results checkout. This is a one-time, idempotent local-config write (never a
-// global/user config change) plus materializing the dependency-free driver
-// script into the checkout's git dir. `.gitattributes` on the branch maps the
-// overlay paths to this driver; together they let resolveResultBranchPushConflict
-// auto-merge concurrent writes without ever force-pushing.
+// Install artifact-aware merge attributes in the AgentV-owned results checkout.
+// This is a one-time, idempotent local-config write (never global/user config).
+// The committed `.gitattributes` keeps the same JSONL union rules portable to
+// other clients.
 async function ensureResultsMergeConfig(repoDir: string): Promise<void> {
   let gitDir: string;
   try {
@@ -821,30 +699,8 @@ async function ensureResultsMergeConfig(repoDir: string): Promise<void> {
     return;
   }
 
-  const driverScriptPath = path.join(gitDir, 'agentv', 'json-merge-driver.mjs');
-  let scriptCurrent = false;
-  try {
-    scriptCurrent = readFileSync(driverScriptPath, 'utf8') === RESULTS_JSON_MERGE_DRIVER_SCRIPT;
-  } catch {
-    scriptCurrent = false;
-  }
-  if (!scriptCurrent) {
-    mkdirSync(path.dirname(driverScriptPath), { recursive: true });
-    writeFileSync(driverScriptPath, RESULTS_JSON_MERGE_DRIVER_SCRIPT, { mode: 0o755 });
-  }
-
-  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,
-  });
-
   // Also mirror the merge attributes into the repo-local `info/attributes`. The
-  // committed `.gitattributes` makes the drivers portable to other clients, but
+  // committed `.gitattributes` makes the rules portable to other clients, but
   // info/attributes guarantees they apply to *this* checkout's merges even on
   // branches committed before `.gitattributes` existed, and for both the
   // working-tree merge and the detached `merge-tree` paths.
@@ -1577,28 +1433,58 @@ function withActionFlags(
 }
 
 function isSafeResultsRepoPath(p: string): boolean {
+  const normalized = p.split(path.sep).join('/');
+  const segments = normalized.split('/').filter(Boolean);
+  const isRunBundlePath =
+    segments.length >= 2 &&
+    !segments[0]?.startsWith('.') &&
+    segments[0] !== RESULTS_REPO_GITATTRIBUTES_FILE;
   return (
-    p === RESULTS_REPO_GITATTRIBUTES_FILE ||
-    RESULTS_REPO_TRACKED_DIRS.some((dir) => p === dir || p.startsWith(`${dir}/`))
+    normalized === RESULTS_REPO_GITATTRIBUTES_FILE ||
+    RESULTS_REPO_TRACKED_DOT_DIRS.some(
+      (dir) => normalized === dir || normalized.startsWith(`${dir}/`),
+    ) ||
+    isRunBundlePath
   );
 }
 
 // git errors on a pathspec that matches nothing, so when staging AgentV's result
-// trees we only pass the ones that currently exist on disk or in the index. A run
-// commit may have no tag overlays yet (no `metadata/`), and vice versa.
-async function existingTrackedResultsDirs(repoDir: string): Promise<string[]> {
-  const targets: string[] = [];
-  for (const dir of RESULTS_REPO_TRACKED_DIRS) {
+// trees we only pass the ones that currently exist on disk or in the index.
+async function existingTrackedResultsPathspecs(repoDir: string): Promise<string[]> {
+  const targets = new Set<string>();
+  if (existsSync(path.join(repoDir, RESULTS_REPO_GITATTRIBUTES_FILE))) {
+    targets.add(RESULTS_REPO_GITATTRIBUTES_FILE);
+  }
+  for (const dir of RESULTS_REPO_TRACKED_DOT_DIRS) {
     if (existsSync(path.join(repoDir, dir))) {
-      targets.push(dir);
+      targets.add(dir);
       continue;
     }
     const { stdout } = await runGit(['ls-files', '--', dir], { cwd: repoDir, check: false });
     if (stdout.trim().length > 0) {
-      targets.push(dir);
+      targets.add(dir);
+    }
+  }
+  for (const entry of await readdir(repoDir, { withFileTypes: true }).catch(() => [])) {
+    if (entry.name.startsWith('.') || !entry.isDirectory()) {
+      continue;
+    }
+    if (existsSync(path.join(repoDir, entry.name, 'summary.json'))) {
+      targets.add(entry.name);
     }
   }
-  return targets;
+  const { stdout } = await runGit(['ls-files'], { cwd: repoDir, check: false });
+  for (const file of stdout.split(/\r?\n/)) {
+    const normalized = file.trim();
+    if (!normalized) {
+      continue;
+    }
+    const segments = normalized.split('/');
+    if (segments.length >= 2 && segments[0] && !segments[0].startsWith('.')) {
+      targets.add(segments[0]);
+    }
+  }
+  return [...targets].sort();
 }
 
 function areSafeResultsRepoPaths(paths: readonly string[]): boolean {
@@ -1691,7 +1577,7 @@ function buildNeedsHumanMergeReason(
   remoteCommit: string | undefined,
   localCommit: string | undefined,
 ): string {
-  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(
+  return `Results branch ${targetBranch} diverged from the remote and could not be auto-merged: a genuine results content conflict remains (remote ${formatShortSha(
     remoteCommit,
   )}, local ${formatShortSha(
     localCommit,
@@ -1767,7 +1653,7 @@ async function resolveRemotePushUrl(repoDir: string, remote: string): Promise<st
   return undefined;
 }
 
-// Count the unique top-level `runs/<run_id>` run directories that the diverged
+// Count the unique top-level `<run_id>` run directories that the diverged
 // local commit adds on top of the remote target tip. Best-effort: returns
 // undefined when the diff cannot be computed.
 async function countContributedRunDirs(
@@ -1784,7 +1670,7 @@ async function countContributedRunDirs(
       '--name-only',
       `${remoteTargetCommit}...${sourceCommit}`,
       '--',
-      `${RESULTS_REPO_RUNS_DIR}/`,
+      RESULTS_REPO_RUNS_DIR,
     ],
     { cwd: repoDir, check: false },
   );
@@ -1798,9 +1684,9 @@ async function countContributedRunDirs(
       continue;
     }
     const segments = file.split('/');
-    // runs/<run_id>/...
-    if (segments[0] === RESULTS_REPO_RUNS_DIR && segments.length >= 2 && segments[1]) {
-      runDirs.add(`${segments[0]}/${segments[1]}`);
+    // <run_id>/...
+    if (segments.length >= 2 && segments[0] && !segments[0].startsWith('.')) {
+      runDirs.add(segments[0]);
     }
   }
   return runDirs.size;
@@ -1892,8 +1778,8 @@ async function mergeRemoteIntoCheckedOutBranch(
 // Layer 1 of the no-force-push results sync (see
 // docs/adr/0007-conflict-free-results-sync-without-force-push.md). A bounded
 // fetch → merge → push loop: fast-forward when possible, otherwise commit a real
-// 3-way merge using the artifact-aware drivers (union index, agentv-json
-// overlay) and fast-forward the canonical branch onto it. A genuine overlay
+// 3-way merge using the artifact-aware JSONL union rules and fast-forward the
+// canonical branch onto it. A genuine results content
 // conflict returns a `needs_human_merge` blocked outcome — never a force push.
 async function resolveResultBranchPushConflict(params: {
   readonly normalized: StorageBranchResultsConfig;
@@ -2513,10 +2399,16 @@ export async function syncResultsRepoForProject(config: ResultsConfig): Promise<
       }
 
       if (inspection.syncStatus === 'dirty') {
-        const trackedDirs = await existingTrackedResultsDirs(repoDir);
-        await runGit(['add', '--all', '--', ...trackedDirs], { cwd: repoDir });
+        const trackedPathspecs = await existingTrackedResultsPathspecs(repoDir);
+        await runGit(['add', '--all', '--', ...trackedPathspecs], { cwd: repoDir });
         await runGitWithFallbackCommitIdentity(
-          ['commit', '-m', 'chore(results): sync local result metadata', '--', ...trackedDirs],
+          [
+            'commit',
+            '-m',
+            'chore(results): sync local results branch changes',
+            '--',
+            ...trackedPathspecs,
+          ],
           {
             cwd: repoDir,
           },
@@ -3039,13 +2931,22 @@ function resolveLocalResultManifestPath(sourceDir: string): string | undefined {
   try {
     const summary = JSON.parse(readFileSync(path.join(sourceDir, 'summary.json'), 'utf8')) as {
       manifest_path?: unknown;
+      index_path?: unknown;
     };
-    const manifestPath = safeLocalSummaryManifestPath(sourceDir, summary.manifest_path);
+    const manifestPath = safeLocalSummaryManifestPath(
+      sourceDir,
+      summary.index_path ?? summary.manifest_path,
+    );
     if (manifestPath && existsSync(manifestPath)) {
       return manifestPath;
     }
   } catch {}
 
+  const internalManifestPath = path.join(sourceDir, '.internal', RESULT_INDEX_FILENAME);
+  if (existsSync(internalManifestPath)) {
+    return internalManifestPath;
+  }
+
   const manifestPath = path.join(sourceDir, RESULT_INDEX_FILENAME);
   if (existsSync(manifestPath)) {
     return manifestPath;
@@ -3201,7 +3102,7 @@ async function preparePublishedResultsSource(params: {
     for (const sourceFile of sourceFiles) {
       const relativeFile = path.relative(params.sourceDir, sourceFile).split(path.sep).join('/');
       const destinationFile = path.join(publishedRoot, ...relativeFile.split('/'));
-      if (isResultManifestFilename(relativeFile)) {
+      if (isResultManifestFilename(path.posix.basename(relativeFile))) {
         const original = readFileSync(sourceFile, 'utf8');
         const rewritten = original
           .split(/\r?\n/)
@@ -3851,6 +3752,7 @@ type GitBatchBlob = {
 
 type GitRunSummary = {
   readonly manifest_path?: string;
+  readonly index_path?: string;
   readonly metadata?: {
     readonly display_name?: string;
     readonly timestamp?: string;
@@ -3893,17 +3795,20 @@ function buildGitManifestPaths(
     if (!isV2ResultsRepoRunPath(relativeRunPath)) {
       continue;
     }
-    const manifestPath = safeGitSummaryManifestPath(runDir, summary.manifest_path);
+    const manifestPath = safeGitSummaryManifestPath(
+      runDir,
+      summary.index_path ?? summary.manifest_path,
+    );
     if (manifestPath && treePathSet.has(manifestPath)) {
       manifestByRunDir.set(runDir, manifestPath);
     }
   }
 
   for (const treePath of treePaths) {
-    if (!treePath.endsWith(`/${RESULT_INDEX_FILENAME}`)) {
+    if (!treePath.endsWith(`/.internal/${RESULT_INDEX_FILENAME}`)) {
       continue;
     }
-    const runDir = path.posix.dirname(treePath);
+    const runDir = gitRunDirForManifestPath(treePath);
     const relativeRunPath = path.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
     if (!isV2ResultsRepoRunPath(relativeRunPath)) {
       continue;
@@ -3916,6 +3821,11 @@ function buildGitManifestPaths(
   return [...manifestByRunDir.values()].sort();
 }
 
+function gitRunDirForManifestPath(manifestPath: string): string {
+  const manifestDir = path.posix.dirname(manifestPath);
+  return path.posix.basename(manifestDir) === '.internal' ? path.posix.dirname(manifestDir) : manifestDir;
+}
+
 function isV2ResultsRepoRunPath(relativeRunPath: string): boolean {
   const segments = relativeRunPath.split('/').filter(Boolean);
   return segments.length === 1 && !segments[0].startsWith('.');
@@ -4097,7 +4007,7 @@ export async function readGitResultArtifact(
 //
 // Manual recovery: if a pod is lost mid-run, an operator can clone the results
 // repo, checkout `agentv/wip/<hostname>/<run-dir>`, and resume with:
-//   cp -r runs/<run-dir> <local-workspace>
+//   cp -r <run-dir> <local-workspace>
 //   agentv eval <eval-file> --output <local-workspace>/<run-dir> --resume
 
 export function buildWipBranchName(runDir: string): string {
@@ -4183,8 +4093,11 @@ export async function pushWipCheckpoint(params: {
     sourceDir: params.sourceDir,
     destinationDir,
   });
-  const trackedDirs = await existingTrackedResultsDirs(params.handle.worktreeDir);
-  await runGit(['add', '--all', '--', ...trackedDirs], {
+  writeFileSync(
+    path.join(params.handle.worktreeDir, RESULTS_REPO_GITATTRIBUTES_FILE),
+    RESULTS_REPO_GITATTRIBUTES_CONTENT,
+  );
+  await runGit(['add', '--all', '--', RESULTS_REPO_GITATTRIBUTES_FILE, params.destinationPath], {
     cwd: params.handle.worktreeDir,
   });
   const { stdout: status } = await runGit(['status', '--porcelain'], {
@@ -4456,7 +4369,7 @@ export async function listGitRuns(repoDir: string, ref = 'origin/main'): Promise
 
   const runs = blobs.flatMap((blob, index): GitListedRun[] => {
     const manifestPath = indexPaths[index];
-    const runDir = path.posix.dirname(manifestPath);
+    const runDir = gitRunDirForManifestPath(manifestPath);
     const summaryPath = path.posix.join(runDir, 'summary.json');
     const summary = summaryByPath.get(summaryPath);
     const relativeRunPath = path.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
diff --git a/packages/core/test/evaluation/results-repo.test.ts b/packages/core/test/evaluation/results-repo.test.ts
index 3a02fc857..7c103963a 100644
--- a/packages/core/test/evaluation/results-repo.test.ts
+++ b/packages/core/test/evaluation/results-repo.test.ts
@@ -140,9 +140,9 @@ async function createStaleResultBranchPushFixture(params: {
   });
 
   git(`git switch --quiet ${params.storageBranch}`, params.seedDir);
-  const remoteOnlyPath = path.join(params.seedDir, 'runs', '2026-06-23T09-30-00-000Z');
+  const remoteOnlyPath = path.join(params.seedDir, '2026-06-23T09-30-00-000Z');
   writeRunArtifacts(remoteOnlyPath, 'remote-only', '2026-06-23T09:30:00.000Z');
-  git('git add runs && git commit --quiet -m "remote result wins race"', params.seedDir);
+  git('git add . && git commit --quiet -m "remote result wins race"', params.seedDir);
   git(`git push --quiet origin HEAD:${params.storageBranch}`, params.seedDir);
   git('git switch --quiet main', params.seedDir);
 
@@ -160,84 +160,20 @@ async function createStaleResultBranchPushFixture(params: {
   };
 }
 
-// Sets up a genuine (non-auto-mergeable) overlay conflict where the canonical
-// results branch is `agentv/results/v1` (the clone's default/checked-out
-// branch). The local checkout and the remote both commit a conflicting scalar
-// field on the same overlay file, so a sync routes to the Layer 2 human-merge
-// path (needs_human_merge + a temp branch). The canonical branch name is
-// deliberately the nested-looking `agentv/results/v1` to prove the flat
-// temp-branch name never D/F-conflicts with it.
-async function setupCanonicalOverlayConflict(rootDir: string): Promise<{
-  remoteDir: string;
-  seedDir: string;
-  cloneDir: string;
-  targetBranch: string;
-  tagsRel: string;
-  config: ResultsConfig;
-  remoteBefore: string;
-}> {
-  const targetBranch = DEFAULT_RESULTS_BRANCH;
-  const remoteDir = path.join(rootDir, `remote-${randomToken()}.git`);
-  const seedDir = path.join(rootDir, `seed-${randomToken()}`);
-  git(`git init --bare --initial-branch=${targetBranch} --quiet "${remoteDir}"`, rootDir);
-  git(`git clone --quiet "${remoteDir}" "${seedDir}"`, rootDir);
-  git('git config user.email "test@example.com"', seedDir);
-  git('git config user.name "Test User"', seedDir);
-
-  const tagsRel = path.join(
-    'metadata',
-    'runs',
-    'conflict',
-    '2026-06-24T10-00-00-000Z',
-    'tags.json',
-  );
-  const writeOverlay = (repoDir: string, rating: number) => {
-    const tagPath = path.join(repoDir, tagsRel);
-    mkdirSync(path.dirname(tagPath), { recursive: true });
-    writeFileSync(tagPath, `${JSON.stringify({ tags: ['keep'], rating }, null, 2)}\n`);
-  };
-
-  writeFileSync(path.join(seedDir, 'README.md'), '# results\n');
-  writeOverlay(seedDir, 1);
-  git('git add . && git commit --quiet -m "seed overlay"', seedDir);
-  git(`git push --quiet origin HEAD:${targetBranch}`, seedDir);
-
-  const cloneDir = path.join(rootDir, `results-clone-${randomToken()}`);
-  const config: ResultsConfig = {
-    repo: `file://${remoteDir}`,
-    path: cloneDir,
-    auto_push: true,
-  };
-  await ensureResultsRepoClone(config);
-  git('git config user.email "test@example.com"', cloneDir);
-  git('git config user.name "Test User"', cloneDir);
-  git('git pull --ff-only --quiet', cloneDir);
-
-  // Local edit: a conflicting scalar (rating=3) committed on the canonical branch.
-  writeOverlay(cloneDir, 3);
-  git('git add metadata && git commit --quiet -m "local overlay scalar"', cloneDir);
-
-  // Remote advances with a different conflicting scalar (rating=5).
-  writeOverlay(seedDir, 5);
-  git('git add metadata && git commit --quiet -m "remote overlay scalar"', seedDir);
-  git(`git push --quiet origin HEAD:${targetBranch}`, seedDir);
-  const remoteBefore = git(`git --git-dir "${remoteDir}" rev-parse ${targetBranch}`, rootDir);
-
-  return { remoteDir, seedDir, cloneDir, targetBranch, tagsRel, config, remoteBefore };
-}
-
 function randomToken(): string {
   return Math.random().toString(36).slice(2, 8);
 }
 
 function writeRunArtifacts(runDir: string, experiment: string, timestamp: string): void {
   mkdirSync(runDir, { recursive: true });
-  writeFileSync(path.join(runDir, 'index.jsonl'), '{"test_id":"alpha"}\n');
+  const internalDir = path.join(runDir, '.internal');
+  mkdirSync(internalDir, { recursive: true });
+  writeFileSync(path.join(internalDir, 'index.jsonl'), '{"test_id":"alpha"}\n');
   writeFileSync(
     path.join(runDir, 'summary.json'),
     JSON.stringify(
       {
-        manifest_path: 'index.jsonl',
+        index_path: '.internal/index.jsonl',
         metadata: {
           timestamp,
           experiment,
@@ -288,7 +224,7 @@ function writeRunArtifactsWithPointers(
   const legacyTraceSha = sha256Hex(legacyTraceContent);
   const transcriptSha = sha256Hex(transcriptContent);
   writeFileSync(
-    path.join(runDir, 'index.jsonl'),
+    path.join(runDir, '.internal', 'index.jsonl'),
     `${JSON.stringify({
       test_id: 'alpha',
       score: 1,
@@ -397,10 +333,11 @@ describe('listGitRuns', () => {
   });
 
   it('returns committed runs derived from canonical index.jsonl manifests', async () => {
-    const defaultRunDir = path.join(repoDir, 'runs', '2026-05-20T10-00-00-000Z');
-    mkdirSync(defaultRunDir, { recursive: true });
+    const defaultRunDir = path.join(repoDir, '2026-05-20T10-00-00-000Z');
+    const defaultInternalDir = path.join(defaultRunDir, '.internal');
+    mkdirSync(defaultInternalDir, { recursive: true });
     writeFileSync(
-      path.join(defaultRunDir, 'index.jsonl'),
+      path.join(defaultInternalDir, 'index.jsonl'),
       `${[
         JSON.stringify({
           test_id: 'alpha',
@@ -434,10 +371,11 @@ describe('listGitRuns', () => {
       ),
     );
 
-    const experimentRunDir = path.join(repoDir, 'runs', '2026-05-21T11-00-00-000Z');
-    mkdirSync(experimentRunDir, { recursive: true });
+    const experimentRunDir = path.join(repoDir, '2026-05-21T11-00-00-000Z');
+    const experimentInternalDir = path.join(experimentRunDir, '.internal');
+    mkdirSync(experimentInternalDir, { recursive: true });
     writeFileSync(
-      path.join(experimentRunDir, 'index.jsonl'),
+      path.join(experimentInternalDir, 'index.jsonl'),
       `${[
         JSON.stringify({
           test_id: 'alpha',
@@ -460,7 +398,7 @@ describe('listGitRuns', () => {
       path.join(experimentRunDir, 'summary.json'),
       JSON.stringify(
         {
-          manifest_path: 'index.jsonl',
+          index_path: '.internal/index.jsonl',
           metadata: {
             display_name: 'remote friendly run',
             timestamp: '2026-05-21T11:00:00.000Z',
@@ -482,7 +420,7 @@ describe('listGitRuns', () => {
       ),
     );
 
-    git('git add runs && git commit -m "seed runs"', repoDir);
+    git('git add . && git commit -m "seed runs"', repoDir);
 
     const runs = await listGitRuns(repoDir, 'HEAD');
 
@@ -495,8 +433,8 @@ describe('listGitRuns', () => {
       experiment: 'with-skills',
       timestamp: '2026-05-21T11:00:00.000Z',
       display_name: 'remote friendly run',
-      manifest_path: 'runs/2026-05-21T11-00-00-000Z/index.jsonl',
-      summary_path: 'runs/2026-05-21T11-00-00-000Z/summary.json',
+      manifest_path: '2026-05-21T11-00-00-000Z/.internal/index.jsonl',
+      summary_path: '2026-05-21T11-00-00-000Z/summary.json',
       test_count: 3,
       pass_rate: 0.75,
       avg_score: 0,
@@ -506,7 +444,7 @@ describe('listGitRuns', () => {
       experiment: 'default',
       display_name: '2026-05-20T10-00-00-000Z',
       target: 'gpt-4o',
-      manifest_path: 'runs/2026-05-20T10-00-00-000Z/index.jsonl',
+      manifest_path: '2026-05-20T10-00-00-000Z/.internal/index.jsonl',
       test_count: 2,
       pass_rate: 0.5,
     });
@@ -528,10 +466,11 @@ describe('listGitRuns', () => {
   });
 
   it('ignores inherited git hook environment variables', async () => {
-    const runDir = path.join(repoDir, 'runs', '2026-05-20T10-00-00-000Z');
-    mkdirSync(runDir, { recursive: true });
+    const runDir = path.join(repoDir, '2026-05-20T10-00-00-000Z');
+    const internalDir = path.join(runDir, '.internal');
+    mkdirSync(internalDir, { recursive: true });
     writeFileSync(
-      path.join(runDir, 'index.jsonl'),
+      path.join(internalDir, 'index.jsonl'),
       `${JSON.stringify({
         test_id: 'alpha',
         target: 'gpt-4o',
@@ -542,7 +481,7 @@ describe('listGitRuns', () => {
       path.join(runDir, 'summary.json'),
       JSON.stringify(
         {
-          manifest_path: 'index.jsonl',
+          index_path: '.internal/index.jsonl',
           metadata: {
             timestamp: '2026-05-20T10:00:00.000Z',
             targets: ['gpt-4o'],
@@ -558,7 +497,7 @@ describe('listGitRuns', () => {
         2,
       ),
     );
-    git('git add runs && git commit -m "seed run"', repoDir);
+    git('git add . && git commit -m "seed run"', repoDir);
 
     const previousGitDir = process.env.GIT_DIR;
     const previousGitWorkTree = process.env.GIT_WORK_TREE;
@@ -585,13 +524,14 @@ describe('listGitRuns', () => {
   });
 
   it('materializes an entire run subtree atomically from git objects', async () => {
-    const runDir = path.join(repoDir, 'runs', '2026-05-22T10-00-00-000Z');
+    const runDir = path.join(repoDir, '2026-05-22T10-00-00-000Z');
+    mkdirSync(path.join(runDir, '.internal'), { recursive: true });
     mkdirSync(path.join(runDir, 'attachments'), { recursive: true });
-    writeFileSync(path.join(runDir, 'index.jsonl'), '{"test_id":"alpha"}\n');
+    writeFileSync(path.join(runDir, '.internal', 'index.jsonl'), '{"test_id":"alpha"}\n');
     writeFileSync(
       path.join(runDir, 'summary.json'),
       JSON.stringify({
-        manifest_path: 'index.jsonl',
+        index_path: '.internal/index.jsonl',
         metadata: {
           timestamp: '2026-05-22T10:00:00.000Z',
           experiment: 'with-files',
@@ -606,13 +546,15 @@ describe('listGitRuns', () => {
       }),
     );
     writeFileSync(path.join(runDir, 'attachments', 'response.md'), 'hello from git\n');
-    git('git add runs && git commit -m "seed run with files"', repoDir);
+    git('git add . && git commit -m "seed run with files"', repoDir);
 
     rmSync(runDir, { recursive: true, force: true });
 
     await materializeGitRun(repoDir, '2026-05-22T10-00-00-000Z', 'HEAD');
 
-    expect(readFileSync(path.join(runDir, 'index.jsonl'), 'utf8')).toContain('"test_id":"alpha"');
+    expect(readFileSync(path.join(runDir, '.internal', 'index.jsonl'), 'utf8')).toContain(
+      '"test_id":"alpha"',
+    );
     expect(readFileSync(path.join(runDir, 'attachments', 'response.md'), 'utf8')).toBe(
       'hello from git\n',
     );
@@ -638,10 +580,10 @@ describe('listGitRuns', () => {
     const defaultBranch = git('git branch --show-current', repoDir);
     git('git checkout -b agentv-results', repoDir);
 
-    const runDir = path.join(repoDir, 'runs', '2026-06-12T10-00-00-000Z');
+    const runDir = path.join(repoDir, '2026-06-12T10-00-00-000Z');
     writeRunArtifacts(runDir, 'branch-only', '2026-06-12T10:00:00.000Z');
     writeFileSync(path.join(runDir, 'attachments.txt'), 'from branch\n');
-    git('git add runs && git commit -m "seed branch run"', repoDir);
+    git('git add . && git commit -m "seed branch run"', repoDir);
     git(`git checkout ${defaultBranch}`, repoDir);
 
     const runs = await listGitRuns(repoDir, 'agentv-results');
@@ -787,7 +729,7 @@ describe('results repo write path', () => {
     expect(published).toBe(true);
     expect(git('git branch --show-current', projectDir)).toBe('main');
     const branchFiles = git(`git ls-tree -r --name-only ${DEFAULT_RESULTS_BRANCH}`, projectDir);
-    expect(branchFiles).toContain(`runs/${runTimestamp}/summary.json`);
+    expect(branchFiles).toContain(`${runTimestamp}/summary.json`);
     expect(branchFiles).not.toContain('README.md');
     expect(branchFiles).not.toContain('UNRELATED.txt');
     expect(git('git status --short --branch', projectDir)).toContain('## main');
@@ -959,7 +901,7 @@ describe('results repo write path', () => {
       `git --git-dir "${remoteDir}" ls-tree -r --name-only ${DEFAULT_RESULTS_BRANCH}`,
       rootDir,
     );
-    expect(remoteFiles).toContain(`runs/${runTimestamp}/summary.json`);
+    expect(remoteFiles).toContain(`${runTimestamp}/summary.json`);
     expect(remoteFiles).not.toContain('README.md');
   }, 20000);
 
@@ -995,271 +937,6 @@ describe('results repo write path', () => {
     ).toBe('');
   }, 20000);
 
-  it('commits repo_path metadata overlays to the configured storage branch during sync', async () => {
-    const { remoteDir, seedDir } = initializeRemoteRepo(rootDir);
-    const storageBranch = initializeRemoteStorageBranch(seedDir, DEFAULT_RESULTS_BRANCH);
-    const projectDir = path.join(rootDir, 'source-project-metadata-sync');
-    git(`git clone --quiet "${remoteDir}" "${projectDir}"`, rootDir);
-    git('git config user.email "test@example.com"', projectDir);
-    git('git config user.name "Test User"', projectDir);
-    git(`git fetch --quiet origin ${storageBranch}`, projectDir);
-
-    const tagPath = path.join(
-      projectDir,
-      'metadata',
-      'runs',
-      '2026-06-22T00-19-03-060Z',
-      'tags.json',
-    );
-    mkdirSync(path.dirname(tagPath), { recursive: true });
-    writeFileSync(
-      tagPath,
-      `${JSON.stringify({ tags: ['dogfood'], updated_at: '2026-06-22T00:00:00.000Z' }, null, 2)}\n`,
-    );
-
-    const config: ResultsConfig = {
-      repo_path: projectDir,
-      branch: storageBranch,
-      remote: 'origin',
-      auto_push: true,
-    };
-
-    await expect(getResultsRepoSyncStatus(config)).resolves.toMatchObject({
-      sync_status: 'dirty',
-      dirty_paths: ['metadata/runs/2026-06-22T00-19-03-060Z/tags.json'],
-    });
-
-    const status = await syncResultsRepoForProject(config);
-
-    expect(status).toMatchObject({
-      sync_status: 'clean',
-      commit_created: true,
-      push_performed: true,
-      blocked: false,
-      branch: storageBranch,
-      upstream: `origin/${storageBranch}`,
-    });
-    expect(
-      git(`git --git-dir "${remoteDir}" ls-tree -r --name-only ${storageBranch}`, rootDir),
-    ).toContain('metadata/runs/2026-06-22T00-19-03-060Z/tags.json');
-    await expect(getResultsRepoSyncStatus(config)).resolves.toMatchObject({
-      sync_status: 'clean',
-      dirty_paths: [],
-    });
-    expect(git('git branch --show-current', projectDir)).toBe('main');
-  }, 20000);
-
-  it('fast-forwards a clean repo_path storage branch during project sync', async () => {
-    const { remoteDir, seedDir } = initializeRemoteRepo(rootDir);
-    const storageBranch = initializeRemoteStorageBranch(seedDir, DEFAULT_RESULTS_BRANCH);
-    const projectDir = path.join(rootDir, 'source-project-repo-path-ff');
-    git(`git clone --quiet "${remoteDir}" "${projectDir}"`, rootDir);
-    git(
-      `git fetch --quiet origin refs/heads/${storageBranch}:refs/heads/${storageBranch}`,
-      projectDir,
-    );
-
-    git(`git switch --quiet ${storageBranch}`, seedDir);
-    const remoteTagPath = path.join(
-      seedDir,
-      'metadata',
-      'runs',
-      '2026-06-22T00-00-00-000Z',
-      'tags.json',
-    );
-    mkdirSync(path.dirname(remoteTagPath), { recursive: true });
-    writeFileSync(remoteTagPath, `${JSON.stringify({ tags: ['remote'] }, null, 2)}\n`);
-    git('git add metadata && git commit --quiet -m "remote tag metadata"', seedDir);
-    git(`git push --quiet origin HEAD:${storageBranch}`, seedDir);
-
-    const config: ResultsConfig = {
-      repo_path: projectDir,
-      branch: storageBranch,
-      remote: 'origin',
-      auto_push: false,
-    };
-
-    const status = await syncResultsRepoForProject(config);
-
-    expect(status).toMatchObject({
-      sync_status: 'clean',
-      pull_performed: true,
-      push_performed: false,
-      commit_created: false,
-      blocked: false,
-      branch: storageBranch,
-      upstream: `origin/${storageBranch}`,
-    });
-    expect(git(`git rev-parse ${storageBranch}`, projectDir)).toBe(
-      git(`git --git-dir "${remoteDir}" rev-parse ${storageBranch}`, rootDir),
-    );
-    expect(git('git branch --show-current', projectDir)).toBe('main');
-  }, 20000);
-
-  it('fast-forwards repo_path metadata overlays before committing and pushing them', async () => {
-    const { remoteDir, seedDir } = initializeRemoteRepo(rootDir);
-    const storageBranch = initializeRemoteStorageBranch(seedDir, DEFAULT_RESULTS_BRANCH);
-    const projectDir = path.join(rootDir, 'source-project-repo-path-dirty-ff');
-    git(`git clone --quiet "${remoteDir}" "${projectDir}"`, rootDir);
-    git('git config user.email "test@example.com"', projectDir);
-    git('git config user.name "Test User"', projectDir);
-    git(
-      `git fetch --quiet origin refs/heads/${storageBranch}:refs/heads/${storageBranch}`,
-      projectDir,
-    );
-
-    git(`git switch --quiet ${storageBranch}`, seedDir);
-    const remoteTagPath = path.join(
-      seedDir,
-      'metadata',
-      'runs',
-      '2026-06-22T00-00-00-000Z',
-      'tags.json',
-    );
-    mkdirSync(path.dirname(remoteTagPath), { recursive: true });
-    writeFileSync(remoteTagPath, `${JSON.stringify({ tags: ['remote'] }, null, 2)}\n`);
-    git('git add metadata && git commit --quiet -m "remote tag metadata"', seedDir);
-    git(`git push --quiet origin HEAD:${storageBranch}`, seedDir);
-
-    const localTagPath = path.join(
-      projectDir,
-      'metadata',
-      'runs',
-      '2026-06-22T01-00-00-000Z',
-      'tags.json',
-    );
-    mkdirSync(path.dirname(localTagPath), { recursive: true });
-    writeFileSync(localTagPath, `${JSON.stringify({ tags: ['local'] }, null, 2)}\n`);
-
-    const config: ResultsConfig = {
-      repo_path: projectDir,
-      branch: storageBranch,
-      remote: 'origin',
-      auto_push: true,
-    };
-
-    const status = await syncResultsRepoForProject(config);
-
-    expect(status).toMatchObject({
-      sync_status: 'clean',
-      pull_performed: true,
-      push_performed: true,
-      commit_created: true,
-      blocked: false,
-      branch: storageBranch,
-      upstream: `origin/${storageBranch}`,
-    });
-    const remoteFiles = git(
-      `git --git-dir "${remoteDir}" ls-tree -r --name-only ${storageBranch}`,
-      rootDir,
-    );
-    expect(remoteFiles).toContain('metadata/runs/2026-06-22T00-00-00-000Z/tags.json');
-    expect(remoteFiles).toContain('metadata/runs/2026-06-22T01-00-00-000Z/tags.json');
-    expect(git('git branch --show-current', projectDir)).toBe('main');
-  }, 20000);
-
-  it('blocks repo_path metadata sync when upstream changed the same dirty path', async () => {
-    const { remoteDir, seedDir } = initializeRemoteRepo(rootDir);
-    const storageBranch = initializeRemoteStorageBranch(seedDir, DEFAULT_RESULTS_BRANCH);
-    const projectDir = path.join(rootDir, 'source-project-repo-path-dirty-ff-conflict');
-    git(`git clone --quiet "${remoteDir}" "${projectDir}"`, rootDir);
-    git('git config user.email "test@example.com"', projectDir);
-    git('git config user.name "Test User"', projectDir);
-    git(
-      `git fetch --quiet origin refs/heads/${storageBranch}:refs/heads/${storageBranch}`,
-      projectDir,
-    );
-
-    const metadataPath = 'metadata/runs/2026-06-22T03-00-00-000Z/tags.json';
-    git(`git switch --quiet ${storageBranch}`, seedDir);
-    const remoteTagPath = path.join(seedDir, ...metadataPath.split('/'));
-    mkdirSync(path.dirname(remoteTagPath), { recursive: true });
-    writeFileSync(remoteTagPath, `${JSON.stringify({ tags: ['remote'] }, null, 2)}\n`);
-    git('git add metadata && git commit --quiet -m "remote shared tag metadata"', seedDir);
-    git(`git push --quiet origin HEAD:${storageBranch}`, seedDir);
-
-    const localTagPath = path.join(projectDir, ...metadataPath.split('/'));
-    mkdirSync(path.dirname(localTagPath), { recursive: true });
-    writeFileSync(localTagPath, `${JSON.stringify({ tags: ['local'] }, null, 2)}\n`);
-
-    const status = await syncResultsRepoForProject({
-      repo_path: projectDir,
-      branch: storageBranch,
-      remote: 'origin',
-      auto_push: true,
-    });
-
-    expect(status).toMatchObject({
-      sync_status: 'conflicted',
-      pull_performed: false,
-      push_performed: false,
-      commit_created: false,
-      blocked: true,
-      branch: storageBranch,
-      upstream: `origin/${storageBranch}`,
-      dirty_paths: [metadataPath],
-      conflicted_paths: [metadataPath],
-    });
-    expect(status.block_reason).toContain(metadataPath);
-    expect(
-      git(`git --git-dir "${remoteDir}" show ${storageBranch}:${metadataPath}`, rootDir),
-    ).toContain('"remote"');
-    expect(readFileSync(localTagPath, 'utf8')).toContain('"local"');
-    expect(git('git branch --show-current', projectDir)).toBe('main');
-  }, 20000);
-
-  it('reports repo_path metadata push rejection without dropping the local commit', async () => {
-    const { remoteDir, seedDir } = initializeRemoteRepo(rootDir);
-    const storageBranch = initializeRemoteStorageBranch(seedDir, DEFAULT_RESULTS_BRANCH);
-    const projectDir = path.join(rootDir, 'source-project-repo-path-rejected-push');
-    git(`git clone --quiet "${remoteDir}" "${projectDir}"`, rootDir);
-    git('git config user.email "test@example.com"', projectDir);
-    git('git config user.name "Test User"', projectDir);
-    git(
-      `git fetch --quiet origin refs/heads/${storageBranch}:refs/heads/${storageBranch}`,
-      projectDir,
-    );
-
-    const tagPath = path.join(
-      projectDir,
-      'metadata',
-      'runs',
-      '2026-06-22T02-00-00-000Z',
-      'tags.json',
-    );
-    mkdirSync(path.dirname(tagPath), { recursive: true });
-    writeFileSync(tagPath, `${JSON.stringify({ tags: ['local'] }, null, 2)}\n`);
-
-    const hookPath = path.join(remoteDir, 'hooks', 'pre-receive');
-    writeFileSync(hookPath, '#!/usr/bin/env sh\necho "reject metadata push" >&2\nexit 1\n');
-    chmodSync(hookPath, 0o755);
-
-    const status = await syncResultsRepoForProject({
-      repo_path: projectDir,
-      branch: storageBranch,
-      remote: 'origin',
-      auto_push: true,
-    });
-
-    expect(status).toMatchObject({
-      sync_status: 'ahead',
-      pull_performed: false,
-      push_performed: false,
-      commit_created: true,
-      blocked: true,
-      branch: storageBranch,
-      upstream: `origin/${storageBranch}`,
-    });
-    expect(status.block_reason).toContain('Results repo push was rejected');
-    expect(git(`git ls-tree -r --name-only ${storageBranch}`, projectDir)).toContain(
-      'metadata/runs/2026-06-22T02-00-00-000Z/tags.json',
-    );
-    expect(
-      git(`git --git-dir "${remoteDir}" ls-tree -r --name-only ${storageBranch}`, rootDir),
-    ).not.toContain('metadata/runs/2026-06-22T02-00-00-000Z/tags.json');
-    expect(git('git branch --show-current', projectDir)).toBe('main');
-  }, 20000);
-
   it('publishes to an explicit external local repo path', async () => {
     const projectDir = path.join(rootDir, 'project');
     const resultsRepoDir = path.join(rootDir, 'local-results-repo');
@@ -1289,7 +966,7 @@ describe('results repo write path', () => {
     expect(published).toBe(true);
     expect(git('git branch --show-current', resultsRepoDir)).toBe('main');
     const branchFiles = git(`git ls-tree -r --name-only ${DEFAULT_RESULTS_BRANCH}`, resultsRepoDir);
-    expect(branchFiles).toContain(`runs/${runTimestamp}/index.jsonl`);
+    expect(branchFiles).toContain(`${runTimestamp}/.internal/index.jsonl`);
     expect(branchFiles).not.toContain('README.md');
   }, 20000);
 
@@ -1320,7 +997,7 @@ describe('results repo write path', () => {
     ).rejects.toThrow(/simulated interrupted push/);
     expect(git('git rev-list --count origin/main..main', cloneDir)).toBe('1');
     expect(git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, rootDir)).not.toContain(
-      `runs/${runTimestamp}/summary.json`,
+      `${runTimestamp}/summary.json`,
     );
 
     rmSync(hookPath, { force: true });
@@ -1336,7 +1013,7 @@ describe('results repo write path', () => {
 
     expect(git('git rev-list --count origin/main..main', cloneDir)).toBe('0');
     expect(git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, rootDir)).toContain(
-      `runs/${runTimestamp}/summary.json`,
+      `${runTimestamp}/summary.json`,
     );
     expect(git(`git --git-dir "${remoteDir}" log -1 --pretty=%B main`, rootDir)).toContain(
       `AgentV-Run: ${runTimestamp}`,
@@ -1388,8 +1065,8 @@ describe('results repo write path', () => {
       `git --git-dir "${remoteDir}" ls-tree -r --name-only ${storageBranch}`,
       rootDir,
     );
-    expect(remoteFiles).toContain(`runs/${fixture.localDestinationPath}/summary.json`);
-    expect(remoteFiles).toContain('runs/2026-06-23T09-30-00-000Z/summary.json');
+    expect(remoteFiles).toContain(`${fixture.localDestinationPath}/summary.json`);
+    expect(remoteFiles).toContain('2026-06-23T09-30-00-000Z/summary.json');
     // No backup ref was ever created in the merge path.
     expect(
       git(`git --git-dir "${remoteDir}" for-each-ref refs/heads/agentv/backups`, rootDir),
@@ -1465,7 +1142,7 @@ describe('results repo write path', () => {
       rootDir,
     );
     expect(remoteFiles).toContain('RACE.md');
-    expect(remoteFiles).toContain('runs/2026-06-24T10-00-00-000Z/summary.json');
+    expect(remoteFiles).toContain('2026-06-24T10-00-00-000Z/summary.json');
     expect(
       git(`git --git-dir "${remoteDir}" for-each-ref refs/heads/agentv/backups`, rootDir),
     ).toBe('');
@@ -1498,7 +1175,7 @@ describe('results repo write path', () => {
       `AgentV-Run: ${runTimestamp}`,
     );
     expect(git('git ls-tree -r --name-only main', cloneDir)).toContain(
-      `runs/${runTimestamp}/index.jsonl`,
+      `${runTimestamp}/.internal/index.jsonl`,
     );
 
     const runs = await listGitRuns(cloneDir, 'main');
@@ -1533,11 +1210,11 @@ describe('results repo write path', () => {
     expect(pushed).toBe(true);
     expect(git('git branch --show-current', cloneDir)).toBe('main');
     expect(git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, rootDir)).not.toContain(
-      `runs/${runTimestamp}/summary.json`,
+      `${runTimestamp}/summary.json`,
     );
     expect(
       git(`git --git-dir "${remoteDir}" ls-tree -r --name-only ${storageBranch}`, rootDir),
-    ).toContain(`runs/${runTimestamp}/summary.json`);
+    ).toContain(`${runTimestamp}/summary.json`);
     expect(
       git(`git --git-dir "${remoteDir}" log -1 --pretty=%B ${storageBranch}`, rootDir),
     ).toContain(`AgentV-Run: ${runTimestamp}`);
@@ -1571,23 +1248,23 @@ describe('results repo write path', () => {
       `git --git-dir "${remoteDir}" ls-tree -r --name-only ${storageBranch}`,
       rootDir,
     );
-    expect(resultTree).toContain(`runs/${destinationPath}/index.jsonl`);
-    expect(resultTree).toContain(`runs/${destinationPath}/summary.json`);
-    expect(resultTree).not.toContain(`runs/${destinationPath}/alpha/trace.json`);
-    expect(resultTree).not.toContain(`runs/${destinationPath}/alpha/transcript.jsonl`);
+    expect(resultTree).toContain(`${destinationPath}/.internal/index.jsonl`);
+    expect(resultTree).toContain(`${destinationPath}/summary.json`);
+    expect(resultTree).not.toContain(`${destinationPath}/alpha/trace.json`);
+    expect(resultTree).not.toContain(`${destinationPath}/alpha/transcript.jsonl`);
 
     const artifactTree = git(
       `git --git-dir "${remoteDir}" ls-tree -r --name-only ${AGENTV_RESULTS_REFS.artifacts}`,
       rootDir,
     );
-    expect(artifactTree).not.toContain(`runs/${destinationPath}/alpha/trace.json`);
-    expect(artifactTree).toContain(`runs/${destinationPath}/alpha/transcript.jsonl`);
-    expect(artifactTree).not.toContain(`runs/${destinationPath}/summary.json`);
-    expect(artifactTree).not.toContain(`runs/${destinationPath}/index.jsonl`);
+    expect(artifactTree).not.toContain(`${destinationPath}/alpha/trace.json`);
+    expect(artifactTree).toContain(`${destinationPath}/alpha/transcript.jsonl`);
+    expect(artifactTree).not.toContain(`${destinationPath}/summary.json`);
+    expect(artifactTree).not.toContain(`${destinationPath}/.internal/index.jsonl`);
 
     const index = JSON.parse(
       gitRaw(
-        `git --git-dir "${remoteDir}" show ${storageBranch}:runs/${destinationPath}/index.jsonl`,
+        `git --git-dir "${remoteDir}" show ${storageBranch}:${destinationPath}/.internal/index.jsonl`,
         rootDir,
       ).toString('utf8'),
     );
@@ -1599,7 +1276,7 @@ describe('results repo write path', () => {
       sha256: string;
       object_version: string;
     }>) {
-      expect(pointer.key).toBe(`runs/${destinationPath}/${pointer.path}`);
+      expect(pointer.key).toBe(`${destinationPath}/${pointer.path}`);
       const bytes = gitRaw(
         `git --git-dir "${remoteDir}" show ${AGENTV_RESULTS_REFS.artifacts}:${pointer.key}`,
         rootDir,
@@ -1645,10 +1322,10 @@ describe('results repo write path', () => {
 
     git(`git switch --quiet --orphan ${storageBranch}`, seedDir);
     git('git rm -rf --quiet . 2>/dev/null || true', seedDir);
-    const seededRunDir = path.join(seedDir, 'runs', destinationPath);
+    const seededRunDir = path.join(seedDir, destinationPath);
     mkdirSync(path.dirname(seededRunDir), { recursive: true });
     cpSync(sourceDir, seededRunDir, { recursive: true });
-    git('git add runs && git commit --quiet -m "seed published run"', seedDir);
+    git('git add . && git commit --quiet -m "seed published run"', seedDir);
     git(`git push --quiet origin HEAD:${storageBranch}`, seedDir);
     git('git switch --quiet main', seedDir);
     const seededResultsHead = git(
@@ -1674,16 +1351,16 @@ describe('results repo write path', () => {
       `git --git-dir "${remoteDir}" ls-tree -r --name-only ${storageBranch}`,
       rootDir,
     );
-    expect(resultTree).toContain(`runs/${destinationPath}/index.jsonl`);
-    expect(resultTree).toContain(`runs/${destinationPath}/summary.json`);
-    expect(resultTree).not.toContain(`runs/${destinationPath}/alpha/trace.json`);
-    expect(resultTree).not.toContain(`runs/${destinationPath}/alpha/transcript.jsonl`);
+    expect(resultTree).toContain(`${destinationPath}/.internal/index.jsonl`);
+    expect(resultTree).toContain(`${destinationPath}/summary.json`);
+    expect(resultTree).not.toContain(`${destinationPath}/alpha/trace.json`);
+    expect(resultTree).not.toContain(`${destinationPath}/alpha/transcript.jsonl`);
     const artifactTree = git(
       `git --git-dir "${remoteDir}" ls-tree -r --name-only ${AGENTV_RESULTS_REFS.artifacts}`,
       rootDir,
     );
-    expect(artifactTree).not.toContain(`runs/${destinationPath}/alpha/trace.json`);
-    expect(artifactTree).toContain(`runs/${destinationPath}/alpha/transcript.jsonl`);
+    expect(artifactTree).not.toContain(`${destinationPath}/alpha/trace.json`);
+    expect(artifactTree).toContain(`${destinationPath}/alpha/transcript.jsonl`);
 
     await expect(
       directPushResults({
@@ -1718,7 +1395,7 @@ describe('results repo write path', () => {
     );
     expect(
       git(`git --git-dir "${remoteDir}" ls-tree -r --name-only agentv-results`, rootDir),
-    ).toContain('runs/2026-06-12T11-00-00-000Z/summary.json');
+    ).toContain('2026-06-12T11-00-00-000Z/summary.json');
   }, 20000);
 
   it('syncResultsRepo refreshes refs without checking out the base branch', async () => {
@@ -1757,9 +1434,9 @@ describe('results repo write path', () => {
       behind: 0,
     });
 
-    const localRunDir = path.join(cloneDir, 'runs', '2026-05-23T10-00-00-000Z');
+    const localRunDir = path.join(cloneDir, '2026-05-23T10-00-00-000Z');
     writeRunArtifacts(localRunDir, 'local-only', '2026-05-23T10:00:00.000Z');
-    git('git add runs && git commit --quiet -m "local result"', cloneDir);
+    git('git add . && git commit --quiet -m "local result"', cloneDir);
 
     await expect(getResultsRepoSyncStatus(config)).resolves.toMatchObject({
       sync_status: 'ahead',
@@ -1839,7 +1516,7 @@ describe('results repo write path', () => {
     );
   }, 20000);
 
-  it('commits and pushes safe dirty result metadata when auto_push is enabled', async () => {
+  it('commits and pushes safe dirty result artifacts when auto_push is enabled', async () => {
     const { remoteDir } = initializeRemoteRepo(rootDir);
     const cloneDir = path.join(rootDir, 'results-clone');
     const config = createResultsConfig(remoteDir, cloneDir);
@@ -1849,7 +1526,7 @@ describe('results repo write path', () => {
     git('git config user.name "Test User"', cloneDir);
 
     const runTimestamp = '2026-05-24T10-00-00-000Z';
-    const runDir = path.join(cloneDir, 'runs', runTimestamp);
+    const runDir = path.join(cloneDir, runTimestamp);
     writeRunArtifacts(runDir, 'metadata', '2026-05-24T10:00:00.000Z');
 
     const status = await syncResultsRepoForProject(config);
@@ -1861,7 +1538,7 @@ describe('results repo write path', () => {
       blocked: false,
     });
     expect(git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, rootDir)).toContain(
-      `runs/${runTimestamp}/summary.json`,
+      `${runTimestamp}/summary.json`,
     );
   }, 20000);
 
@@ -1899,7 +1576,7 @@ describe('results repo write path', () => {
     writeFileSync(path.join(cloneDir, 'package.json'), '{"dependencies":{"agentv":"next"}}\n');
 
     const runTimestamp = '2026-05-24T11-00-00-000Z';
-    const runDir = path.join(cloneDir, 'runs', runTimestamp);
+    const runDir = path.join(cloneDir, runTimestamp);
     writeRunArtifacts(runDir, 'safe-run', '2026-05-24T11:00:00.000Z');
 
     const status = await syncResultsRepoForProject(config);
@@ -1912,7 +1589,7 @@ describe('results repo write path', () => {
     });
     expect(status.dirty_paths).toEqual([]);
     expect(git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, rootDir)).toContain(
-      `runs/${runTimestamp}/summary.json`,
+      `${runTimestamp}/summary.json`,
     );
     expect(git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, rootDir)).not.toContain(
       'package.json',
@@ -1934,7 +1611,7 @@ describe('results repo write path', () => {
     git('git add package.json', cloneDir);
 
     const runTimestamp = '2026-05-24T11-30-00-000Z';
-    const runDir = path.join(cloneDir, 'runs', runTimestamp);
+    const runDir = path.join(cloneDir, runTimestamp);
     writeRunArtifacts(runDir, 'staged-unrelated', '2026-05-24T11:30:00.000Z');
 
     const status = await syncResultsRepoForProject(config);
@@ -1946,7 +1623,7 @@ describe('results repo write path', () => {
       blocked: false,
     });
     const remoteFiles = git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, rootDir);
-    expect(remoteFiles).toContain(`runs/${runTimestamp}/summary.json`);
+    expect(remoteFiles).toContain(`${runTimestamp}/summary.json`);
     expect(remoteFiles).not.toContain('package.json');
     expect(git('git status --porcelain', cloneDir)).toContain('A  package.json');
   }, 20000);
@@ -1992,7 +1669,7 @@ describe('results repo write path', () => {
     git('git push --quiet origin main', seedDir);
 
     const runTimestamp = '2026-05-24T12-00-00-000Z';
-    const runDir = path.join(cloneDir, 'runs', runTimestamp);
+    const runDir = path.join(cloneDir, runTimestamp);
     writeRunArtifacts(runDir, 'pulled-then-pushed', '2026-05-24T12:00:00.000Z');
 
     const status = await syncResultsRepoForProject(config);
@@ -2006,7 +1683,7 @@ describe('results repo write path', () => {
     });
     const remoteFiles = git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, rootDir);
     expect(remoteFiles).toContain('REMOTE.md');
-    expect(remoteFiles).toContain(`runs/${runTimestamp}/summary.json`);
+    expect(remoteFiles).toContain(`${runTimestamp}/summary.json`);
     expect(remoteFiles).not.toContain('package.json');
     expect(readFileSync(path.join(cloneDir, 'package.json'), 'utf8')).toBe(
       '{"dependencies":{"agentv":"next"}}\n',
@@ -2022,13 +1699,13 @@ describe('results repo write path', () => {
     git('git config user.email "test@example.com"', cloneDir);
     git('git config user.name "Test User"', cloneDir);
 
-    const runDir = path.join(cloneDir, 'runs', '2026-05-25T10-00-00-000Z');
+    const runDir = path.join(cloneDir, '2026-05-25T10-00-00-000Z');
     writeRunArtifacts(runDir, 'local-only', '2026-05-25T10:00:00.000Z');
-    git('git add runs && git commit --quiet -m "local result"', cloneDir);
+    git('git add . && git commit --quiet -m "local result"', cloneDir);
 
-    const remoteRunDir = path.join(seedDir, 'runs', '2026-05-25T11-00-00-000Z');
+    const remoteRunDir = path.join(seedDir, '2026-05-25T11-00-00-000Z');
     writeRunArtifacts(remoteRunDir, 'remote-only', '2026-05-25T11:00:00.000Z');
-    git('git add runs && git commit --quiet -m "remote result"', seedDir);
+    git('git add . && git commit --quiet -m "remote result"', seedDir);
     const remoteBefore = git('git rev-parse HEAD', seedDir);
     git('git push --quiet origin main', seedDir);
 
@@ -2051,8 +1728,8 @@ describe('results repo write path', () => {
       ),
     ).not.toThrow();
     const remoteFiles = git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, rootDir);
-    expect(remoteFiles).toContain('runs/2026-05-25T10-00-00-000Z/summary.json');
-    expect(remoteFiles).toContain('runs/2026-05-25T11-00-00-000Z/summary.json');
+    expect(remoteFiles).toContain('2026-05-25T10-00-00-000Z/summary.json');
+    expect(remoteFiles).toContain('2026-05-25T11-00-00-000Z/summary.json');
     expect(
       git(`git --git-dir "${remoteDir}" for-each-ref refs/heads/agentv/backups`, rootDir),
     ).toBe('');
@@ -2062,7 +1739,7 @@ describe('results repo write path', () => {
     const { remoteDir, seedDir } = initializeRemoteRepo(rootDir);
     const cloneDir = path.join(rootDir, 'results-clone');
     const config = createResultsConfig(remoteDir, cloneDir);
-    const indexRel = path.join('runs', '2026-05-25T12-00-00-000Z', 'index.jsonl');
+    const indexRel = path.join('2026-05-25T12-00-00-000Z', '.internal', 'index.jsonl');
 
     await ensureResultsRepoClone(config);
     git('git config user.email "test@example.com"', cloneDir);
@@ -2072,16 +1749,16 @@ describe('results repo write path', () => {
     const seedIndex = path.join(seedDir, indexRel);
     mkdirSync(path.dirname(seedIndex), { recursive: true });
     writeFileSync(seedIndex, '{"test_id":"base"}\n');
-    git('git add runs && git commit --quiet -m "seed shared index"', seedDir);
+    git('git add . && git commit --quiet -m "seed shared index"', seedDir);
     git('git push --quiet origin main', seedDir);
     git('git pull --ff-only --quiet', cloneDir);
 
     // Local appends one line; the remote concurrently appends a different line.
     const localIndex = path.join(cloneDir, indexRel);
     writeFileSync(localIndex, '{"test_id":"base"}\n{"test_id":"local"}\n');
-    git('git add runs && git commit --quiet -m "local index append"', cloneDir);
+    git('git add . && git commit --quiet -m "local index append"', cloneDir);
     writeFileSync(seedIndex, '{"test_id":"base"}\n{"test_id":"remote"}\n');
-    git('git add runs && git commit --quiet -m "remote index append"', seedDir);
+    git('git add . && git commit --quiet -m "remote index append"', seedDir);
     git('git push --quiet origin main', seedDir);
 
     const status = await syncResultsRepoForProject(config);
@@ -2095,216 +1772,6 @@ describe('results repo write path', () => {
     expect(merged).toContain('"test_id":"remote"');
   }, 20000);
 
-  it('auto-merges overlay tag additions from both sides via the agentv-json driver', async () => {
-    const { remoteDir, seedDir } = initializeRemoteRepo(rootDir);
-    const cloneDir = path.join(rootDir, 'results-clone');
-    const config = createResultsConfig(remoteDir, cloneDir);
-    const tagsRel = path.join(
-      'metadata',
-      'runs',
-      'overlay',
-      '2026-05-26T10-00-00-000Z',
-      'tags.json',
-    );
-    const writeTags = (repoDir: string, tags: string[], revision: string) => {
-      const tagPath = path.join(repoDir, tagsRel);
-      mkdirSync(path.dirname(tagPath), { recursive: true });
-      writeFileSync(
-        tagPath,
-        `${JSON.stringify({ tags, updated_at: '2026-05-26T10:00:00.000Z', tag_revision: revision }, null, 2)}\n`,
-      );
-    };
-
-    await ensureResultsRepoClone(config);
-    git('git config user.email "test@example.com"', cloneDir);
-    git('git config user.name "Test User"', cloneDir);
-
-    writeTags(seedDir, ['base'], 'r0');
-    git('git add metadata && git commit --quiet -m "seed tags"', seedDir);
-    git('git push --quiet origin main', seedDir);
-    git('git pull --ff-only --quiet', cloneDir);
-
-    writeTags(cloneDir, ['base', 'local-tag'], 'r1');
-    git('git add metadata && git commit --quiet -m "local tag add"', cloneDir);
-    writeTags(seedDir, ['base', 'remote-tag'], 'r2');
-    git('git add metadata && git commit --quiet -m "remote tag add"', seedDir);
-    git('git push --quiet origin main', seedDir);
-
-    const status = await syncResultsRepoForProject(config);
-
-    expect(status.sync_status).toBe('clean');
-    expect(status.blocked).toBe(false);
-    expect(status.push_performed).toBe(true);
-
-    const mergedTags = JSON.parse(
-      git(`git --git-dir "${remoteDir}" show main:${tagsRel}`, rootDir),
-    );
-    expect(mergedTags.tags).toContain('base');
-    expect(mergedTags.tags).toContain('local-tag');
-    expect(mergedTags.tags).toContain('remote-tag');
-    // The content-derived concurrency token must NOT survive a real set merge as
-    // either side's pre-merge value; otherwise a stale client holding that token
-    // would bypass the optimistic-concurrency check and overwrite the union.
-    expect(mergedTags.tag_revision).not.toBe('r1');
-    expect(mergedTags.tag_revision).not.toBe('r2');
-    expect(
-      git(`git --git-dir "${remoteDir}" for-each-ref refs/heads/agentv/backups`, rootDir),
-    ).toBe('');
-  }, 20000);
-
-  it('returns needs_human_merge on a genuine overlay conflict without changing the remote', async () => {
-    const { remoteDir, seedDir } = initializeRemoteRepo(rootDir);
-    const cloneDir = path.join(rootDir, 'results-clone');
-    const config = createResultsConfig(remoteDir, cloneDir);
-    const tagsRel = path.join(
-      'metadata',
-      'runs',
-      'conflict',
-      '2026-05-27T10-00-00-000Z',
-      'tags.json',
-    );
-    const writeOverlay = (repoDir: string, rating: number) => {
-      const tagPath = path.join(repoDir, tagsRel);
-      mkdirSync(path.dirname(tagPath), { recursive: true });
-      writeFileSync(tagPath, `${JSON.stringify({ tags: ['keep'], rating }, null, 2)}\n`);
-    };
-
-    await ensureResultsRepoClone(config);
-    git('git config user.email "test@example.com"', cloneDir);
-    git('git config user.name "Test User"', cloneDir);
-
-    writeOverlay(seedDir, 1);
-    git('git add metadata && git commit --quiet -m "seed overlay"', seedDir);
-    git('git push --quiet origin main', seedDir);
-    git('git pull --ff-only --quiet', cloneDir);
-
-    // Both sides set a genuinely conflicting non-tag scalar field.
-    writeOverlay(cloneDir, 3);
-    git('git add metadata && git commit --quiet -m "local overlay scalar"', cloneDir);
-    writeOverlay(seedDir, 5);
-    git('git add metadata && git commit --quiet -m "remote overlay scalar"', seedDir);
-    const remoteBefore = git('git rev-parse HEAD', seedDir);
-    git('git push --quiet origin main', seedDir);
-
-    const status = await syncResultsRepoForProject(config);
-
-    expect(status.sync_status).toBe('needs_human_merge');
-    expect(status.blocked).toBe(true);
-    expect(status.block_reason).not.toMatch(/force/i);
-    // The remote branch is untouched: no merge commit, no force, no backup.
-    expect(git(`git --git-dir "${remoteDir}" rev-parse main`, rootDir)).toBe(remoteBefore);
-    expect(
-      git(`git --git-dir "${remoteDir}" for-each-ref refs/heads/agentv/backups`, rootDir),
-    ).toBe('');
-    // The local checkout is clean (the failed merge was aborted).
-    expect(git('git status --porcelain', cloneDir)).toBe('');
-  }, 20000);
-
-  it('pushes diverged work to a flat temp branch and surfaces pending_merge on a genuine conflict', async () => {
-    const { remoteDir, cloneDir, targetBranch, tagsRel, config, remoteBefore } =
-      await setupCanonicalOverlayConflict(rootDir);
-
-    const status = await syncResultsRepoForProject(config);
-
-    expect(status.sync_status).toBe('needs_human_merge');
-    expect(status.blocked).toBe(true);
-    expect(status.block_reason).not.toMatch(/force/i);
-
-    // A pending_merge wire block (snake_case) is surfaced for the Dashboard.
-    const pending = status.pending_merge;
-    expect(pending).toBeDefined();
-    expect(pending?.target_branch).toBe(targetBranch);
-    expect(typeof pending?.created_at).toBe('string');
-    expect(typeof pending?.contributed_run_count).toBe('number');
-    // The branch is flat under a dedicated namespace, never nested under the
-    // canonical branch, so it cannot D/F-conflict with agentv/results/v1.
-    expect(pending?.temp_branch).toMatch(/^agentv\/results-sync\/.+/);
-    expect(pending?.temp_branch.startsWith(`${targetBranch}/`)).toBe(false);
-    // Snake_case keys only on the wire shape.
-    expect(Object.keys(pending ?? {})).toEqual(
-      expect.arrayContaining(['temp_branch', 'target_branch', 'created_at']),
-    );
-    // A non-GitHub (file://) remote yields no compare_url.
-    expect(pending?.compare_url).toBeUndefined();
-
-    const tempBranch = pending?.temp_branch ?? '';
-    // The temp branch exists on the remote alongside the canonical branch (the
-    // create-only push succeeded — no D/F-conflict) and carries the local work.
-    const remoteRefs = git(
-      `git --git-dir "${remoteDir}" for-each-ref --format="%(refname:short)" refs/heads`,
-      rootDir,
-    );
-    expect(remoteRefs).toContain(tempBranch);
-    expect(remoteRefs).toContain(targetBranch);
-    const overlayOnTemp = JSON.parse(
-      git(`git --git-dir "${remoteDir}" show ${tempBranch}:${tagsRel}`, rootDir),
-    );
-    expect(overlayOnTemp.rating).toBe(3);
-
-    // The canonical branch is untouched: no merge commit, no force, no backup.
-    expect(git(`git --git-dir "${remoteDir}" rev-parse ${targetBranch}`, rootDir)).toBe(
-      remoteBefore,
-    );
-    expect(
-      git(`git --git-dir "${remoteDir}" for-each-ref refs/heads/agentv/backups`, rootDir),
-    ).toBe('');
-
-    // The local work is intact on disk.
-    expect(JSON.parse(readFileSync(path.join(cloneDir, tagsRel), 'utf8')).rating).toBe(3);
-  }, 30000);
-
-  it('clears the pending merge after the temp branch is merged into the target', async () => {
-    const { remoteDir, cloneDir, targetBranch, tagsRel, config } =
-      await setupCanonicalOverlayConflict(rootDir);
-
-    const blocked = await syncResultsRepoForProject(config);
-    expect(blocked.sync_status).toBe('needs_human_merge');
-    const tempBranch = blocked.pending_merge?.temp_branch ?? '';
-    expect(tempBranch).not.toBe('');
-
-    // Simulate the user merging the temp branch into the target on GitHub: a
-    // fresh clone merges the temp branch (resolving the scalar toward the temp
-    // side) and pushes the result onto the canonical branch.
-    const mergeDir = path.join(rootDir, `merge-${randomToken()}`);
-    git(`git clone --quiet "${remoteDir}" "${mergeDir}"`, rootDir);
-    git('git config user.email "merge@example.com"', mergeDir);
-    git('git config user.name "Merge Bot"', mergeDir);
-    git(`git fetch --quiet origin "+refs/heads/*:refs/remotes/origin/*"`, mergeDir);
-    git(`git checkout --quiet -B ${targetBranch} origin/${targetBranch}`, mergeDir);
-    git(`git merge --no-edit -X theirs origin/${tempBranch}`, mergeDir);
-    git(`git push --quiet origin HEAD:${targetBranch}`, mergeDir);
-
-    const resumed = await confirmResultsMergeAndPull(config);
-
-    expect(resumed.blocked ?? false).toBe(false);
-    expect(resumed.sync_status).not.toBe('needs_human_merge');
-    expect(resumed.sync_status).toBe('clean');
-    expect(resumed.pending_merge).toBeUndefined();
-    // The local checkout now matches the merged target which carries the work.
-    expect(JSON.parse(readFileSync(path.join(cloneDir, tagsRel), 'utf8')).rating).toBe(3);
-  }, 30000);
-
-  it('keeps local work intact on a premature confirm-merge (target not yet merged)', async () => {
-    const { cloneDir, targetBranch, tagsRel, config } =
-      await setupCanonicalOverlayConflict(rootDir);
-
-    const blocked = await syncResultsRepoForProject(config);
-    expect(blocked.sync_status).toBe('needs_human_merge');
-    const firstTempBranch = blocked.pending_merge?.temp_branch ?? '';
-
-    // OK clicked without merging on GitHub: pulling the target is a no-op, the
-    // local work stays diverged, and the resumed sync re-creates a temp branch.
-    const resumed = await confirmResultsMergeAndPull(config);
-
-    expect(resumed.sync_status).toBe('needs_human_merge');
-    expect(resumed.blocked).toBe(true);
-    expect(resumed.pending_merge?.temp_branch).toMatch(/^agentv\/results-sync\/.+/);
-    expect(resumed.pending_merge?.target_branch).toBe(targetBranch);
-    // No data loss: the local work survives the premature OK.
-    expect(JSON.parse(readFileSync(path.join(cloneDir, tagsRel), 'utf8')).rating).toBe(3);
-    expect(firstTempBranch).not.toBe('');
-  }, 30000);
-
   it('builds a GitHub compare URL only for GitHub remotes', () => {
     expect(
       buildResultsCompareUrl(
@@ -2326,57 +1793,6 @@ describe('results repo write path', () => {
     expect(buildResultsCompareUrl(undefined, 'main', 'temp')).toBeUndefined();
   });
 
-  it('supersedes stale sync errors with the current conflicted status', async () => {
-    const { remoteDir, seedDir } = initializeRemoteRepo(rootDir);
-    const cloneDir = path.join(rootDir, 'results-clone');
-    const config = { ...createResultsConfig(remoteDir, cloneDir), auto_push: false };
-    const relativeMetadataPath = path.join(
-      'metadata',
-      'runs',
-      'stale-error',
-      '2026-05-26T10-00-00-000Z',
-      'tags.json',
-    );
-    const writeTags = (repoDir: string, rating: number) => {
-      const tagPath = path.join(repoDir, relativeMetadataPath);
-      mkdirSync(path.dirname(tagPath), { recursive: true });
-      writeFileSync(tagPath, `${JSON.stringify({ tags: ['keep'], rating }, null, 2)}\n`);
-    };
-
-    await ensureResultsRepoClone(config);
-    git('git config user.email "test@example.com"', cloneDir);
-    git('git config user.name "Test User"', cloneDir);
-
-    writeTags(cloneDir, 0);
-    const dirtyStatus = await syncResultsRepoForProject(config);
-    expect(dirtyStatus.sync_status).toBe('dirty');
-    expect(dirtyStatus.block_reason).toContain('auto_push is disabled');
-
-    git('git reset --hard --quiet', cloneDir);
-    git('git clean -fd --quiet metadata', cloneDir);
-
-    writeTags(seedDir, 1);
-    git('git add metadata && git commit --quiet -m "seed tag metadata"', seedDir);
-    git('git push --quiet origin main', seedDir);
-    git('git pull --ff-only --quiet', cloneDir);
-
-    // Both sides set a genuinely conflicting scalar so the agentv-json driver
-    // leaves the overlay conflicted instead of auto-merging it.
-    writeTags(cloneDir, 3);
-    git('git add metadata && git commit --quiet -m "local tag metadata"', cloneDir);
-    writeTags(seedDir, 5);
-    git('git add metadata && git commit --quiet -m "remote tag metadata"', seedDir);
-    git('git push --quiet origin main', seedDir);
-    git('git fetch --quiet origin --prune', cloneDir);
-    git('git merge origin/main || true', cloneDir);
-
-    const status = await getResultsRepoSyncStatus(config);
-
-    expect(status.sync_status).toBe('conflicted');
-    expect(status.last_error).toBe('Results repo has unresolved git conflicts');
-    expect(status.last_error).not.toContain('auto_push is disabled');
-    expect(status.conflicted_paths).toEqual([relativeMetadataPath]);
-  }, 20000);
 });
 
 describe('results branch stable genesis', () => {
@@ -2479,7 +1895,7 @@ describe('results branch stable genesis', () => {
     expect(isAncestor(remoteDir, mainSha, DEFAULT_RESULTS_BRANCH)).toBe(false);
     expect(
       git(`git --git-dir "${remoteDir}" ls-tree -r --name-only ${DEFAULT_RESULTS_BRANCH}`, rootDir),
-    ).toContain('runs/2026-06-19T10-00-00-000Z/summary.json');
+    ).toContain('2026-06-19T10-00-00-000Z/summary.json');
   }, 20000);
 
   it('mints a byte-identical genesis root regardless of wall-clock time', async () => {
@@ -2539,8 +1955,8 @@ describe('results branch stable genesis', () => {
       `git --git-dir "${remoteDir}" ls-tree -r --name-only ${DEFAULT_RESULTS_BRANCH}`,
       rootDir,
     );
-    expect(tree).toContain('runs/2026-06-19T10-00-00-000Z/summary.json');
-    expect(tree).toContain('runs/2026-06-19T11-00-00-000Z/summary.json');
+    expect(tree).toContain('2026-06-19T10-00-00-000Z/summary.json');
+    expect(tree).toContain('2026-06-19T11-00-00-000Z/summary.json');
   }, 30000);
 
   it('reconciles two independent first-inits onto a single shared genesis', async () => {
@@ -2581,8 +1997,8 @@ describe('results branch stable genesis', () => {
       `git --git-dir "${remoteDir}" ls-tree -r --name-only ${DEFAULT_RESULTS_BRANCH}`,
       rootDir,
     );
-    expect(tree).toContain('runs/2026-06-19T10-00-00-000Z/summary.json');
-    expect(tree).toContain('runs/2026-06-19T11-00-00-000Z/summary.json');
+    expect(tree).toContain('2026-06-19T10-00-00-000Z/summary.json');
+    expect(tree).toContain('2026-06-19T11-00-00-000Z/summary.json');
   }, 30000);
 });
 

From 3a8d744cb597ad1b1ba063c995c6761f52b83e55 Mon Sep 17 00:00:00 2001
From: Christopher Tso <christso@gmail.com>
Date: Fri, 3 Jul 2026 14:56:28 +0200
Subject: [PATCH 2/3] format results branch root layout

---
 packages/core/src/evaluation/results-repo.ts       | 12 ++++--------
 packages/core/test/evaluation/results-repo.test.ts |  1 -
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/packages/core/src/evaluation/results-repo.ts b/packages/core/src/evaluation/results-repo.ts
index e9e0fbb6a..b9b96ba6f 100644
--- a/packages/core/src/evaluation/results-repo.ts
+++ b/packages/core/src/evaluation/results-repo.ts
@@ -1665,13 +1665,7 @@ async function countContributedRunDirs(
     return undefined;
   }
   const { stdout, exitCode } = await runGit(
-    [
-      'diff',
-      '--name-only',
-      `${remoteTargetCommit}...${sourceCommit}`,
-      '--',
-      RESULTS_REPO_RUNS_DIR,
-    ],
+    ['diff', '--name-only', `${remoteTargetCommit}...${sourceCommit}`, '--', RESULTS_REPO_RUNS_DIR],
     { cwd: repoDir, check: false },
   );
   if (exitCode !== 0) {
@@ -3823,7 +3817,9 @@ function buildGitManifestPaths(
 
 function gitRunDirForManifestPath(manifestPath: string): string {
   const manifestDir = path.posix.dirname(manifestPath);
-  return path.posix.basename(manifestDir) === '.internal' ? path.posix.dirname(manifestDir) : manifestDir;
+  return path.posix.basename(manifestDir) === '.internal'
+    ? path.posix.dirname(manifestDir)
+    : manifestDir;
 }
 
 function isV2ResultsRepoRunPath(relativeRunPath: string): boolean {
diff --git a/packages/core/test/evaluation/results-repo.test.ts b/packages/core/test/evaluation/results-repo.test.ts
index 7c103963a..fce1fc1ea 100644
--- a/packages/core/test/evaluation/results-repo.test.ts
+++ b/packages/core/test/evaluation/results-repo.test.ts
@@ -1792,7 +1792,6 @@ describe('results repo write path', () => {
     ).toBeUndefined();
     expect(buildResultsCompareUrl(undefined, 'main', 'temp')).toBeUndefined();
   });
-
 });
 
 describe('results branch stable genesis', () => {

From 44f8b0c0d411bfa957f57cdea79563d8a3136b65 Mon Sep 17 00:00:00 2001
From: Christopher Tso <christso@gmail.com>
Date: Fri, 3 Jul 2026 15:23:02 +0200
Subject: [PATCH 3/3] fix(results): align remote readers with root layout

---
 apps/cli/src/commands/results/remote.ts       | 11 ++++--
 .../commands/results/serve-file-tree.test.ts  |  2 +-
 apps/cli/src/commands/results/serve.ts        | 18 ++++++---
 .../results/remote-auto-export.test.ts        | 22 +++++------
 apps/cli/test/commands/results/serve.test.ts  | 39 ++++++++-----------
 packages/core/src/evaluation/results-repo.ts  | 24 +++++++++---
 6 files changed, 67 insertions(+), 49 deletions(-)

diff --git a/apps/cli/src/commands/results/remote.ts b/apps/cli/src/commands/results/remote.ts
index 2e31b6527..e9a298c0e 100644
--- a/apps/cli/src/commands/results/remote.ts
+++ b/apps/cli/src/commands/results/remote.ts
@@ -496,12 +496,17 @@ export async function ensureRemoteRunAvailable(
     throw new Error(`Remote manifest path is outside the results repo clone: ${meta.path}`);
   }
 
-  // On the results branch runs live flat under `runs/` (the branch namespaces
-  // results), so strip that prefix to recover <run_id>.
-  const relativeRunPath = path.posix.relative('runs', path.posix.dirname(relativeManifestPath));
+  const relativeRunPath = relativeRunPathFromManifestPath(relativeManifestPath);
   await materializeGitRun(config.path, relativeRunPath, getResultsStorageRef(config));
 }
 
+function relativeRunPathFromManifestPath(relativeManifestPath: string): string {
+  const manifestDir = path.posix.dirname(relativeManifestPath);
+  return path.posix.basename(manifestDir) === '.internal'
+    ? path.posix.dirname(manifestDir)
+    : manifestDir;
+}
+
 export async function maybeAutoExportRunArtifacts(
   payload: RemoteExportPayload,
 ): Promise<RemoteExportStatus> {
diff --git a/apps/cli/src/commands/results/serve-file-tree.test.ts b/apps/cli/src/commands/results/serve-file-tree.test.ts
index dad66935c..b17ee04a5 100644
--- a/apps/cli/src/commands/results/serve-file-tree.test.ts
+++ b/apps/cli/src/commands/results/serve-file-tree.test.ts
@@ -40,7 +40,7 @@ function gitTranscriptEntry(prefix: string): ArtifactCatalogEntry {
     kind: 'transcript',
     storage: 'git',
     ref: 'agentv/artifacts/v1',
-    key: `runs/2026-06-22T01-12-44-924Z/${prefix}/transcript.jsonl`,
+    key: `2026-06-22T01-12-44-924Z/${prefix}/transcript.jsonl`,
   };
 }
 
diff --git a/apps/cli/src/commands/results/serve.ts b/apps/cli/src/commands/results/serve.ts
index 12e944e35..01853b465 100644
--- a/apps/cli/src/commands/results/serve.ts
+++ b/apps/cli/src/commands/results/serve.ts
@@ -637,12 +637,18 @@ function manifestRecordSelection(
 
 function relativeRunPathFromNormalizedManifestPath(manifestPath: string): string | undefined {
   const parts = manifestPath.split('/').filter(Boolean);
-  const runsIndex = parts.lastIndexOf('runs');
   const manifestName = parts.at(-1);
-  if (runsIndex === -1 || !manifestName || !isRunManifestPath(manifestName)) {
+  if (!manifestName || !isRunManifestPath(manifestName)) {
     return undefined;
   }
-  const runParts = parts.slice(runsIndex + 1, -1);
+  const manifestDirParts = parts.slice(0, -1);
+  if (manifestDirParts.at(-1) === '.internal') {
+    manifestDirParts.pop();
+  }
+  if (manifestDirParts.length === 0 || manifestDirParts[0]?.startsWith('.')) {
+    return undefined;
+  }
+  const runParts = manifestDirParts;
   return runParts.length > 0 ? runParts.join('/') : undefined;
 }
 
@@ -669,7 +675,7 @@ function sidecarArtifactKeyForPointer(
   artifact: ResolvedArtifactPointer,
 ): string | undefined {
   const publishedKey = artifact.key ? normalizeArtifactRelativePath(artifact.key) : undefined;
-  if (publishedKey?.startsWith('runs/')) {
+  if (publishedKey) {
     return publishedKey;
   }
   if (!artifact.path) {
@@ -680,7 +686,7 @@ function sidecarArtifactKeyForPointer(
   if (!relativeArtifactPath || !relativeRunPath) {
     return undefined;
   }
-  return ['runs', relativeRunPath, relativeArtifactPath].join('/');
+  return [relativeRunPath, relativeArtifactPath].join('/');
 }
 
 async function readSidecarArtifactText(
@@ -756,7 +762,7 @@ function displayPathFromArtifactKey(key: string | undefined, runPath: string | u
   const normalizedKey = key ? normalizeArtifactRelativePath(key) : undefined;
   if (!normalizedKey) return undefined;
   if (!runPath) return normalizedKey;
-  const runPrefix = `runs/${runPath}/`;
+  const runPrefix = `${runPath}/`;
   if (!normalizedKey.startsWith(runPrefix)) return normalizedKey;
   return normalizeArtifactRelativePath(normalizedKey.slice(runPrefix.length)) ?? normalizedKey;
 }
diff --git a/apps/cli/test/commands/results/remote-auto-export.test.ts b/apps/cli/test/commands/results/remote-auto-export.test.ts
index 191c9e6d2..7bbf5f938 100644
--- a/apps/cli/test/commands/results/remote-auto-export.test.ts
+++ b/apps/cli/test/commands/results/remote-auto-export.test.ts
@@ -205,7 +205,7 @@ describe('maybeAutoExportRunArtifacts', () => {
 
     expect(status).toBe('published');
     expect(git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, rootDir)).toContain(
-      'runs/run-001/index.jsonl',
+      'run-001/index.jsonl',
     );
   }, 20_000);
 
@@ -227,21 +227,21 @@ describe('maybeAutoExportRunArtifacts', () => {
       `git --git-dir "${remoteDir}" ls-tree -r --name-only ${resultsBranch}`,
       rootDir,
     );
-    expect(resultTree).toContain('runs/run-002/index.jsonl');
-    expect(resultTree).toContain('runs/run-002/summary.json');
-    expect(resultTree).not.toContain('runs/run-002/alpha/trace.json');
-    expect(resultTree).not.toContain('runs/run-002/alpha/transcript.jsonl');
+    expect(resultTree).toContain('run-002/index.jsonl');
+    expect(resultTree).toContain('run-002/summary.json');
+    expect(resultTree).not.toContain('run-002/alpha/trace.json');
+    expect(resultTree).not.toContain('run-002/alpha/transcript.jsonl');
     const index = JSON.parse(
-      git(`git --git-dir "${remoteDir}" show ${resultsBranch}:runs/run-002/index.jsonl`, rootDir),
+      git(`git --git-dir "${remoteDir}" show ${resultsBranch}:run-002/index.jsonl`, rootDir),
     );
     expect(index.artifact_pointers).not.toHaveProperty('trace');
-    expect(index.artifact_pointers.transcript.key).toBe('runs/run-002/alpha/transcript.jsonl');
+    expect(index.artifact_pointers.transcript.key).toBe('run-002/alpha/transcript.jsonl');
     const artifactTree = git(
       `git --git-dir "${remoteDir}" ls-tree -r --name-only ${AGENTV_RESULTS_ARTIFACTS_REF}`,
       rootDir,
     );
-    expect(artifactTree).not.toContain('runs/run-002/alpha/trace.json');
-    expect(artifactTree).toContain('runs/run-002/alpha/transcript.jsonl');
+    expect(artifactTree).not.toContain('run-002/alpha/trace.json');
+    expect(artifactTree).toContain('run-002/alpha/transcript.jsonl');
   }, 20_000);
 
   it('returns already_published when the final results branch is already up to date', async () => {
@@ -316,8 +316,8 @@ describe('maybeAutoExportRunArtifacts', () => {
 
     expect(status).toBe('published');
     expect(git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, rootDir)).not.toContain(
-      'runs/run-001/index.jsonl',
+      'run-001/index.jsonl',
     );
-    expect(git('git ls-tree -r --name-only main', cloneDir)).toContain('runs/run-001/index.jsonl');
+    expect(git('git ls-tree -r --name-only main', cloneDir)).toContain('run-001/index.jsonl');
   });
 });
diff --git a/apps/cli/test/commands/results/serve.test.ts b/apps/cli/test/commands/results/serve.test.ts
index 0676c557a..5c1066e1d 100644
--- a/apps/cli/test/commands/results/serve.test.ts
+++ b/apps/cli/test/commands/results/serve.test.ts
@@ -256,7 +256,7 @@ function writeRemoteRunArtifact(
     /^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/,
     '$1T$2:$3:$4.$5Z',
   );
-  const runDir = path.join(cloneDir, 'runs', timestamp);
+  const runDir = path.join(cloneDir, timestamp);
   mkdirSync(runDir, { recursive: true });
   const records = Array.isArray(resultRecords) ? resultRecords : [resultRecords];
   writeFileSync(path.join(runDir, 'index.jsonl'), toJsonl(...records));
@@ -297,7 +297,7 @@ function writeDirtyRemoteRunArtifact(
     /^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/,
     '$1T$2:$3:$4.$5Z',
   );
-  const runDir = path.join(cloneDir, 'runs', timestamp);
+  const runDir = path.join(cloneDir, timestamp);
   mkdirSync(runDir, { recursive: true });
   writeFileSync(path.join(runDir, 'index.jsonl'), toJsonl(resultRecord));
   writeFileSync(
@@ -1489,12 +1489,7 @@ describe('serve app', () => {
 
       writeResultsConfig(tempDir, { remote: `file://${remoteDir}`, path: cloneDir });
 
-      const runManifestPath = path.join(
-        cloneDir,
-        'runs',
-        '2026-03-26T11-00-00-000Z',
-        'index.jsonl',
-      );
+      const runManifestPath = path.join(cloneDir, '2026-03-26T11-00-00-000Z', 'index.jsonl');
       expect(existsSync(runManifestPath)).toBe(false);
 
       const app = createApp([], tempDir, tempDir, undefined, { studioDir });
@@ -1893,7 +1888,7 @@ describe('serve app', () => {
           '2026-03-26T11-00-00-000Z',
           RESULT_A,
         );
-        git('git add runs && git commit --quiet -m "remote result"', seedDir);
+        git('git add . && git commit --quiet -m "remote result"', seedDir);
         git('git push --quiet origin main', seedDir);
 
         const app = createApp([], tempDir, tempDir, undefined, { studioDir });
@@ -1918,7 +1913,7 @@ describe('serve app', () => {
           blocked: false,
           run_count: 1,
         });
-        expect(existsSync(path.join(cloneDir, 'runs', runId, 'index.jsonl'))).toBe(true);
+        expect(existsSync(path.join(cloneDir, runId, 'index.jsonl'))).toBe(true);
       } finally {
         if (previousHome === undefined) {
           process.env.AGENTV_HOME = undefined;
@@ -1979,7 +1974,7 @@ describe('serve app', () => {
           run_count: 1,
         });
         expect(git(`git --git-dir "${remoteDir}" ls-tree -r --name-only main`, tempDir)).toContain(
-          `runs/${runTimestamp}/index.jsonl`,
+          `${runTimestamp}/index.jsonl`,
         );
       } finally {
         if (previousHome === undefined) {
@@ -2080,14 +2075,14 @@ describe('serve app', () => {
         const cloneRunPath = path.join(cloneDir, relativeRunPath);
         mkdirSync(path.dirname(seedRunPath), { recursive: true });
         writeFileSync(seedRunPath, `${JSON.stringify({ ...RESULT_A, score: 0.5 })}\n`);
-        git('git add runs && git commit --quiet -m "seed run artifact"', seedDir);
+        git('git add . && git commit --quiet -m "seed run artifact"', seedDir);
         git('git push --quiet origin main', seedDir);
         git('git pull --ff-only --quiet', cloneDir);
 
         writeFileSync(cloneRunPath, `${JSON.stringify({ ...RESULT_A, score: 0.75 })}\n`);
-        git('git add runs && git commit --quiet -m "local run edit"', cloneDir);
+        git('git add . && git commit --quiet -m "local run edit"', cloneDir);
         writeFileSync(seedRunPath, `${JSON.stringify({ ...RESULT_A, score: 0.25 })}\n`);
-        git('git add runs && git commit --quiet -m "remote run edit"', seedDir);
+        git('git add . && git commit --quiet -m "remote run edit"', seedDir);
         git('git push --quiet origin main', seedDir);
         git('git fetch --quiet origin --prune', cloneDir);
         git('git merge origin/main || true', cloneDir);
@@ -2156,9 +2151,7 @@ describe('serve app', () => {
       expect(data.sync_status).toBe('clean');
       expect(data.blocked).toBe(false);
       expect(data.run_count).toBe(1);
-      expect(
-        existsSync(path.join(cloneDir, 'runs', '2026-03-26T14-00-00-000Z', 'index.jsonl')),
-      ).toBe(true);
+      expect(existsSync(path.join(cloneDir, '2026-03-26T14-00-00-000Z', 'index.jsonl'))).toBe(true);
       expect(runId).toBe('2026-03-26T14-00-00-000Z');
     }, 15000);
 
@@ -2212,7 +2205,7 @@ describe('serve app', () => {
           blocked: false,
           run_count: 1,
         });
-        expect(existsSync(path.join(cloneDir, 'runs', runId, 'index.jsonl'))).toBe(true);
+        expect(existsSync(path.join(cloneDir, runId, 'index.jsonl'))).toBe(true);
       } finally {
         if (previousHome === undefined) {
           process.env.AGENTV_HOME = undefined;
@@ -3176,8 +3169,8 @@ describe('serve app', () => {
       const runId = `remote::${timestamp}`;
       const transcriptArtifactPath = 'demo/test-greeting/transcript.jsonl';
       const traceArtifactPath = 'demo/test-greeting/trace.json';
-      const transcriptKey = `runs/${timestamp}/${transcriptArtifactPath}`;
-      const traceKey = `runs/${timestamp}/${traceArtifactPath}`;
+      const transcriptKey = `${timestamp}/${transcriptArtifactPath}`;
+      const traceKey = `${timestamp}/${traceArtifactPath}`;
       const transcriptJsonl = `${JSON.stringify({
         schema_version: 'agentv.transcript.v1',
         test_id: 'test-greeting',
@@ -3197,7 +3190,7 @@ describe('serve app', () => {
 
       git(`git switch --quiet --orphan ${resultsBranch}`, seedDir);
       git('git rm -rf --quiet . 2>/dev/null || true', seedDir);
-      const runDir = path.join(seedDir, 'runs', timestamp);
+      const runDir = path.join(seedDir, timestamp);
       mkdirSync(runDir, { recursive: true });
       writeFileSync(
         path.join(runDir, 'index.jsonl'),
@@ -3235,7 +3228,7 @@ describe('serve app', () => {
           2,
         ),
       );
-      git('git add runs && git commit --quiet -m "seed metadata-only results"', seedDir);
+      git('git add . && git commit --quiet -m "seed metadata-only results"', seedDir);
       git(`git push --quiet origin HEAD:${resultsBranch}`, seedDir);
 
       git(`git switch --quiet --orphan ${AGENTV_RESULTS_ARTIFACTS_REF}`, seedDir);
@@ -3245,7 +3238,7 @@ describe('serve app', () => {
       mkdirSync(path.dirname(transcriptPath), { recursive: true });
       writeFileSync(transcriptPath, transcriptJsonl);
       writeFileSync(tracePath, traceJson);
-      git('git add runs && git commit --quiet -m "seed artifact sidecars"', seedDir);
+      git('git add . && git commit --quiet -m "seed artifact sidecars"', seedDir);
       git(`git push --quiet origin HEAD:${AGENTV_RESULTS_ARTIFACTS_REF}`, seedDir);
       git('git switch --quiet main', seedDir);
 
diff --git a/packages/core/src/evaluation/results-repo.ts b/packages/core/src/evaluation/results-repo.ts
index b9b96ba6f..cd7124142 100644
--- a/packages/core/src/evaluation/results-repo.ts
+++ b/packages/core/src/evaluation/results-repo.ts
@@ -3789,17 +3789,16 @@ function buildGitManifestPaths(
     if (!isV2ResultsRepoRunPath(relativeRunPath)) {
       continue;
     }
-    const manifestPath = safeGitSummaryManifestPath(
-      runDir,
-      summary.index_path ?? summary.manifest_path,
-    );
+    const manifestPath =
+      safeGitSummaryManifestPath(runDir, summary.index_path ?? summary.manifest_path) ??
+      fallbackGitManifestPath(runDir, treePathSet);
     if (manifestPath && treePathSet.has(manifestPath)) {
       manifestByRunDir.set(runDir, manifestPath);
     }
   }
 
   for (const treePath of treePaths) {
-    if (!treePath.endsWith(`/.internal/${RESULT_INDEX_FILENAME}`)) {
+    if (!treePath.endsWith(`/${RESULT_INDEX_FILENAME}`)) {
       continue;
     }
     const runDir = gitRunDirForManifestPath(treePath);
@@ -3815,6 +3814,21 @@ function buildGitManifestPaths(
   return [...manifestByRunDir.values()].sort();
 }
 
+function fallbackGitManifestPath(
+  runDir: string,
+  treePathSet: ReadonlySet<string>,
+): string | undefined {
+  for (const candidate of [
+    path.posix.join(runDir, '.internal', RESULT_INDEX_FILENAME),
+    path.posix.join(runDir, RESULT_INDEX_FILENAME),
+  ]) {
+    if (treePathSet.has(candidate)) {
+      return candidate;
+    }
+  }
+  return undefined;
+}
+
 function gitRunDirForManifestPath(manifestPath: string): string {
   const manifestDir = path.posix.dirname(manifestPath);
   return path.posix.basename(manifestDir) === '.internal'