hillclimb 0.9.13 → 0.9.15

package/dist/main.js

@@ -13,8 +13,8 @@ import {
 } from "./chunk-YBBDXGEY.js";
 
 // src/main.ts
-import fs28 from "fs";
-import path27 from "path";
+import fs29 from "fs";
+import path28 from "path";
 import * as p6 from "@clack/prompts";
 
 // src/commands/init.ts
@@ -2937,9 +2937,9 @@ async function runStatus(args = []) {
 // src/commands/upload.ts
 import { spawn as spawn3 } from "child_process";
 import crypto8 from "crypto";
-import fs21 from "fs";
-import os10 from "os";
-import path20 from "path";
+import fs22 from "fs";
+import os11 from "os";
+import path21 from "path";
 
 // src/agent-pending.ts
 import crypto4 from "crypto";
@@ -16194,21 +16194,163 @@ async function recordDebugLogCompletion(args) {
 // src/git-traces/pending-captures.ts
 import { AsyncLocalStorage } from "async_hooks";
 import crypto7 from "crypto";
-import fs20 from "fs";
-import os9 from "os";
-import path19 from "path";
+import fs21 from "fs";
+import os10 from "os";
+import path20 from "path";
 
 // src/git-traces/git-ops.ts
 import { execFileSync as execFileSync2, spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
-import fs18 from "fs";
-import os7 from "os";
-import path17 from "path";
+import fs19 from "fs";
+import os8 from "os";
+import path18 from "path";
 import { createGzip } from "zlib";
 
-// src/git-traces/object-store-probe.ts
-import { spawnSync } from "child_process";
+// src/git-traces/git-diagnostics.ts
 import fs17 from "fs";
+import os7 from "os";
 import path16 from "path";
+import { Worker as Worker2 } from "worker_threads";
+var PHASES = /* @__PURE__ */ new Set([
+  "pack-objects/enumerate-objects",
+  "pack-objects/prepare-pack",
+  "pack-objects/write-pack-file",
+  "index/do_read_index",
+  "index/do_write_index"
+]);
+var COUNTERS = /* @__PURE__ */ new Set([
+  "pack-objects/write_pack_file/wrote",
+  "pack-objects/written",
+  "index/read/cache_nr",
+  "index/write/cache_nr"
+]);
+function summarizeGitTrace(trace, partial = false) {
+  const phases = /* @__PURE__ */ new Map();
+  const active = /* @__PURE__ */ new Set();
+  const counts = /* @__PURE__ */ new Map();
+  const text2 = trace?.subarray(0, 1024 * 1024).toString("utf8") ?? "";
+  const lines = text2.split("\n");
+  partial ||= (trace?.length ?? 0) > 1024 * 1024 || lines.length > 4096;
+  for (const line of lines.slice(0, 4096)) {
+    if (!line) continue;
+    if (line.length > 16384) {
+      partial = true;
+      continue;
+    }
+    try {
+      const e = JSON.parse(line);
+      if (!e || typeof e !== "object") continue;
+      const phase = `${e.category}/${e.label}`;
+      if (e.thread === "main" && PHASES.has(phase)) {
+        if (e.event === "region_enter") active.add(phase);
+        if (e.event === "region_leave" && typeof e.t_rel === "number" && Number.isFinite(e.t_rel) && e.t_rel >= 0 && e.t_rel < 86400) {
+          active.delete(phase);
+          phases.set(phase, Math.round(e.t_rel * 1e3));
+        }
+      }
+      const key = `${e.category}/${e.key}`;
+      if (e.event === "data" && COUNTERS.has(key) && /^\d{1,15}$/.test(String(e.value))) {
+        counts.set(key, Number(e.value));
+      }
+    } catch {
+      partial = true;
+    }
+  }
+  return `traceState=${!text2 ? "unavailable" : partial ? "partial" : "available"}, phasesMs=${JSON.stringify(Object.fromEntries(phases))}, activePhases=${JSON.stringify([...active])}, counts=${JSON.stringify(Object.fromEntries(counts))}`;
+}
+var SAMPLE = {
+  stop: 0,
+  count: 1,
+  cpuMs: 2,
+  elapsedMs: 3,
+  bytes: 4,
+  growthMs: 5
+};
+var TRACE = { ready: 0, length: 1, partial: 2, done: 3 };
+function bundleBytes(file) {
+  let bytes = 0;
+  if (!file) return bytes;
+  for (const candidate of [file, `${file}.lock`]) {
+    try {
+      bytes = Math.max(bytes, fs17.statSync(candidate).size);
+    } catch {
+    }
+  }
+  return bytes;
+}
+function startGitDiagnostics(bundleFile) {
+  const samples = new BigInt64Array(new SharedArrayBuffer(6 * 8));
+  samples[SAMPLE.cpuMs] = -1n;
+  const control = new Int32Array(new SharedArrayBuffer(4 * 4));
+  const trace = Buffer.from(new SharedArrayBuffer(1024 * 1024));
+  let worker;
+  let directory;
+  let socketPath;
+  try {
+    if (process.platform !== "win32") {
+      directory = fs17.mkdtempSync(path16.join(os7.tmpdir(), "hc-git-"));
+      fs17.chmodSync(directory, 448);
+      const candidate = path16.join(directory, "trace.sock");
+      if (Buffer.byteLength(candidate) < 100) socketPath = candidate;
+    }
+    worker = new Worker2(
+      new URL(
+        import.meta.url.endsWith(".ts") ? "./git-diagnostics-worker.ts" : "./git-diagnostics-worker.js",
+        import.meta.url
+      ),
+      {
+        workerData: {
+          samples: samples.buffer,
+          control: control.buffer,
+          trace: trace.buffer,
+          socketPath,
+          parentPid: process.pid,
+          bundleFile,
+          started: Date.now()
+        }
+      }
+    );
+    worker.on("error", () => {
+    });
+    worker.unref();
+    Atomics.wait(control, TRACE.ready, 0, 100);
+  } catch {
+  }
+  return {
+    env: {
+      GIT_TRACE2_EVENT: socketPath && Atomics.load(control, TRACE.ready) === 1 ? `af_unix:stream:${socketPath}` : "0",
+      GIT_TRACE2_EVENT_NESTING: "2",
+      GIT_TRACE2_CONFIG_PARAMS: "",
+      GIT_TRACE2_ENV_VARS: "",
+      GIT_TRACE2_DST_DEBUG: "0"
+    },
+    finish: () => {
+      Atomics.store(samples, SAMPLE.stop, 1n);
+      try {
+        worker?.postMessage("stop");
+        if (worker) Atomics.wait(control, TRACE.done, 0, 100);
+      } catch {
+      }
+      void worker?.terminate().catch(() => {
+      });
+      if (directory) {
+        try {
+          fs17.rmSync(directory, { recursive: true, force: true });
+        } catch {
+        }
+      }
+      const summary = summarizeGitTrace(
+        trace.subarray(0, Atomics.load(control, TRACE.length)),
+        !!Atomics.load(control, TRACE.partial) || !Atomics.load(control, TRACE.done)
+      );
+      return `${summary}, cpuSamples=${Atomics.load(samples, SAMPLE.count)}, sampledCpuMs=${Atomics.load(samples, SAMPLE.cpuMs)}, sampledThroughMs=${Atomics.load(samples, SAMPLE.elapsedMs)}${bundleFile ? `, sampledBundleBytes=${Atomics.load(samples, SAMPLE.bytes)}, lastBundleGrowthMs=${Atomics.load(samples, SAMPLE.growthMs)}, bundleBytes=${bundleBytes(bundleFile)}` : ""}`;
+    }
+  };
+}
+
+// src/git-traces/object-store-probe.ts
+import { spawnSync } from "child_process";
+import fs18 from "fs";
+import path17 from "path";
 var probedRepos = /* @__PURE__ */ new Set();
 var SAMPLE_FANOUT_DIRS = 8;
 var SAMPLE_READS = 20;
@@ -16235,8 +16377,8 @@ function probeObjectStore(repoRoot, trigger, stderr, args = []) {
       return;
     }
     fields.push(`objectsDir=${objectsDir}`);
-    if (typeof fs17.statfsSync === "function") {
-      const stats = fs17.statfsSync(objectsDir);
+    if (typeof fs18.statfsSync === "function") {
+      const stats = fs18.statfsSync(objectsDir);
       fields.push(
         `fsType=${stats.type}`,
         `freeBytes=${stats.bavail * stats.bsize}`
@@ -16244,18 +16386,18 @@ function probeObjectStore(repoRoot, trigger, stderr, args = []) {
     }
     const { estimate, sample } = sampleLooseObjects(objectsDir);
     fields.push(`looseEstimate=${estimate}`);
-    const packDir = path16.join(objectsDir, "pack");
-    const packFiles = fs17.existsSync(packDir) ? fs17.readdirSync(packDir) : [];
+    const packDir = path17.join(objectsDir, "pack");
+    const packFiles = fs18.existsSync(packDir) ? fs18.readdirSync(packDir) : [];
     fields.push(
       `packs=${packFiles.filter((name) => name.endsWith(".pack")).length}`,
       `promisorPacks=${packFiles.filter((name) => name.endsWith(".promisor")).length}`,
-      `alternates=${fs17.existsSync(path16.join(objectsDir, "info", "alternates")) ? "yes" : "no"}`
+      `alternates=${fs18.existsSync(path17.join(objectsDir, "info", "alternates")) ? "yes" : "no"}`
     );
     fields.push(...timeSampleReads(sample));
     const named = namedObjects(stderr);
     for (const sha of named) {
-      const loose = path16.join(objectsDir, sha.slice(0, 2), sha.slice(2));
-      const stats = fs17.statSync(loose, { throwIfNoEntry: false });
+      const loose = path17.join(objectsDir, sha.slice(0, 2), sha.slice(2));
+      const stats = fs18.statSync(loose, { throwIfNoEntry: false });
       fields.push(
         stats ? `named=${sha.slice(0, 8)}(size=${stats.size},blocks=${stats.blocks})` : `named=${sha.slice(0, 8)}(no loose file)`
       );
@@ -16275,30 +16417,30 @@ function probeObjectStore(repoRoot, trigger, stderr, args = []) {
   }
 }
 function resolveObjectsDir(repoRoot) {
-  let gitDir = path16.join(repoRoot, ".git");
-  const stats = fs17.statSync(gitDir, { throwIfNoEntry: false });
+  let gitDir = path17.join(repoRoot, ".git");
+  const stats = fs18.statSync(gitDir, { throwIfNoEntry: false });
   if (!stats) return null;
   if (stats.isFile()) {
-    const match = /^gitdir:\s*(.+)$/m.exec(fs17.readFileSync(gitDir, "utf-8"));
+    const match = /^gitdir:\s*(.+)$/m.exec(fs18.readFileSync(gitDir, "utf-8"));
     if (!match) return null;
-    gitDir = path16.resolve(repoRoot, match[1].trim());
+    gitDir = path17.resolve(repoRoot, match[1].trim());
   }
-  const commonDir = path16.join(gitDir, "commondir");
-  if (fs17.existsSync(commonDir)) {
-    gitDir = path16.resolve(gitDir, fs17.readFileSync(commonDir, "utf-8").trim());
+  const commonDir = path17.join(gitDir, "commondir");
+  if (fs18.existsSync(commonDir)) {
+    gitDir = path17.resolve(gitDir, fs18.readFileSync(commonDir, "utf-8").trim());
   }
-  return path16.join(gitDir, "objects");
+  return path17.join(gitDir, "objects");
 }
 function sampleLooseObjects(objectsDir) {
-  const fanout = fs17.readdirSync(objectsDir).filter((name) => /^[0-9a-f]{2}$/.test(name)).sort().slice(0, SAMPLE_FANOUT_DIRS);
+  const fanout = fs18.readdirSync(objectsDir).filter((name) => /^[0-9a-f]{2}$/.test(name)).sort().slice(0, SAMPLE_FANOUT_DIRS);
   let counted = 0;
   const sample = [];
   for (const dir of fanout) {
-    const files = fs17.readdirSync(path16.join(objectsDir, dir));
+    const files = fs18.readdirSync(path17.join(objectsDir, dir));
     counted += files.length;
     for (const file of files) {
       if (sample.length >= SAMPLE_READS) break;
-      sample.push(path16.join(objectsDir, dir, file));
+      sample.push(path17.join(objectsDir, dir, file));
     }
   }
   return {
@@ -16316,14 +16458,14 @@ function timeSampleReads(sample) {
   for (const file of sample) {
     const readStarted = performance.now();
     try {
-      const stats = fs17.statSync(file);
+      const stats = fs18.statSync(file);
       if (!stats.isFile()) continue;
       if (stats.size > 0 && stats.blocks === 0) dataless++;
-      const fd = fs17.openSync(file, "r");
+      const fd = fs18.openSync(file, "r");
       try {
-        fs17.readSync(fd, buffer, 0, SAMPLE_READ_BYTES, 0);
+        fs18.readSync(fd, buffer, 0, SAMPLE_READ_BYTES, 0);
       } finally {
-        fs17.closeSync(fd);
+        fs18.closeSync(fd);
       }
     } catch (err) {
       readErrors++;
@@ -16348,7 +16490,7 @@ function namedObjects(stderr) {
   return [...shas].slice(0, MAX_NAMED_OBJECTS);
 }
 function sampleSha(file) {
-  const sha = path16.basename(path16.dirname(file)) + path16.basename(file);
+  const sha = path17.basename(path17.dirname(file)) + path17.basename(file);
   return OBJECT_SHA.test(sha) ? sha : null;
 }
 function failedTreeish(args) {
@@ -16425,12 +16567,12 @@ function locateGitRead(fields, repoRoot, objectsDir, treeish, fallback) {
     fields.push(
       `stalledPath=${JSON.stringify(stalled.path.slice(0, MAX_STALLED_PATH_CHARS))}`
     );
-  const loose = path16.join(
+  const loose = path17.join(
     objectsDir,
     stalled.sha.slice(0, 2),
     stalled.sha.slice(2)
   );
-  const stats = fs17.statSync(loose, { throwIfNoEntry: false });
+  const stats = fs18.statSync(loose, { throwIfNoEntry: false });
   fields.push(
     stats ? `stalledLoose=size=${stats.size},blocks=${stats.blocks}` : "stalledLoose=no"
   );
@@ -16466,6 +16608,8 @@ function failureText(result) {
 // src/git-traces/git-ops.ts
 var DEFAULT_GIT_COMMAND_TIMEOUT_MS = 12e4;
 var DEFAULT_BUNDLE_TIMEOUT_MS = 3e5;
+var MAX_BASELINE_BUNDLE_BYTES = 1024 * 1024 * 1024;
+var DEFAULT_UNTRACKED_INDEX_TIMEOUT_MS = 3e5;
 var FULL_TREE_SCAN_TIMEOUT_MS = 3e5;
 function resolveGitCommandTimeoutMs(fallback = DEFAULT_GIT_COMMAND_TIMEOUT_MS) {
   const raw = process.env.HILLCLIMB_GIT_COMMAND_TIMEOUT_MS;
@@ -16654,8 +16798,8 @@ var EXCLUDED_SNAPSHOT_BASENAMES = /* @__PURE__ */ new Set([
 ]);
 var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 function isExcludedSnapshotPath(filePath) {
-  if (EXCLUDED_SNAPSHOT_BASENAMES.has(path17.basename(filePath))) return true;
-  return EXCLUDED_SNAPSHOT_EXTENSIONS.has(path17.extname(filePath).toLowerCase());
+  if (EXCLUDED_SNAPSHOT_BASENAMES.has(path18.basename(filePath))) return true;
+  return EXCLUDED_SNAPSHOT_EXTENSIONS.has(path18.extname(filePath).toLowerCase());
 }
 function isBinaryBuffer(buffer) {
   return buffer.includes(0);
@@ -16676,16 +16820,16 @@ function readTreeBlobHead(repoRoot, sha) {
 function readWorkingFileHead(absPath) {
   let fd = null;
   try {
-    fd = fs18.openSync(absPath, "r");
+    fd = fs19.openSync(absPath, "r");
     const buffer = Buffer.alloc(BINARY_SNIFF_BYTES);
-    const bytesRead = fs18.readSync(fd, buffer, 0, BINARY_SNIFF_BYTES, 0);
+    const bytesRead = fs19.readSync(fd, buffer, 0, BINARY_SNIFF_BYTES, 0);
     return buffer.subarray(0, bytesRead);
   } catch {
     return null;
   } finally {
     if (fd !== null) {
       try {
-        fs18.closeSync(fd);
+        fs19.closeSync(fd);
       } catch {
       }
     }
@@ -16759,6 +16903,7 @@ function createGitError(args, err, timeoutMs = GIT_COMMAND_TIMEOUT_MS, elapsedMs
   const stdout = outputToString(failure.stdout);
   wrapped.gitStdout = stdout ? truncateOutput(stdout) : void 0;
   wrapped.isGitMissingObject = !isTimeout && failure.code !== "ENOBUFS" && matchesMissingObject(stderr);
+  wrapped.isGitMissingWorktreeFile = args[0] === "update-index" && failure.status === 128 && !failure.signal && (!failure.code || failure.code === "EPIPE") && !!stderr?.includes("does not exist and --remove not passed");
   return wrapped;
 }
 function commitTree(repoRoot, treeSha, message) {
@@ -16785,6 +16930,44 @@ function gitBuffer(repoRoot, args, options = {}) {
   const detached = options.killProcessGroup && process.platform !== "win32";
   const started = Date.now();
   try {
+    if (options.diagnostics) {
+      const diagnostics = startGitDiagnostics(options.diagnostics.bundleFile);
+      let status = "failed";
+      try {
+        const result = spawnSync2("git", args, {
+          cwd: repoRoot,
+          env: {
+            ...options.env ?? process.env,
+            ...diagnostics.env
+          },
+          input: options.input,
+          stdio: ["pipe", "pipe", "pipe"],
+          ...EXEC_OPTS,
+          timeout,
+          ...detached ? { detached: true } : {}
+        });
+        if (result.error || result.status !== 0) {
+          throw Object.assign(result.error ?? new Error("Git command failed"), {
+            pid: result.pid,
+            status: result.status,
+            signal: result.signal,
+            stdout: result.stdout,
+            stderr: result.stderr
+          });
+        }
+        status = "ok";
+        return result.stdout;
+      } finally {
+        const elapsedMs = Date.now() - started;
+        const summary = diagnostics.finish();
+        if (status === "failed" || elapsedMs >= 1e3) {
+          appendLog(
+            "info",
+            `git-traces: git diagnostics (stage=${options.diagnostics.stage}, status=${status}, elapsedMs=${elapsedMs}, ${summary})`
+          );
+        }
+      }
+    }
     return execFileSync2("git", args, {
       cwd: repoRoot,
       ...options.env ? { env: options.env } : {},
@@ -16850,23 +17033,23 @@ function withPrivateIndex(repoRoot, run) {
   let tmpDir = null;
   let copy = null;
   try {
-    const indexPath = path17.resolve(
+    const indexPath = path18.resolve(
       repoRoot,
       git(repoRoot, ["rev-parse", "--git-path", "index"])
     );
-    tmpDir = fs18.mkdtempSync(path17.join(os7.tmpdir(), "hillclimb-index-"));
-    copy = path17.join(tmpDir, "index");
-    const fd = fs18.openSync(indexPath, "r");
+    tmpDir = fs19.mkdtempSync(path18.join(os8.tmpdir(), "hillclimb-index-"));
+    copy = path18.join(tmpDir, "index");
+    const fd = fs19.openSync(indexPath, "r");
     let stat;
     let data;
     try {
-      stat = fs18.fstatSync(fd);
-      data = fs18.readFileSync(fd);
+      stat = fs19.fstatSync(fd);
+      data = fs19.readFileSync(fd);
     } finally {
-      fs18.closeSync(fd);
+      fs19.closeSync(fd);
     }
-    fs18.writeFileSync(copy, data);
-    fs18.utimesSync(copy, stat.atime, stat.mtime);
+    fs19.writeFileSync(copy, data);
+    fs19.utimesSync(copy, stat.atime, stat.mtime);
   } catch (err) {
     const missing = err.code === "ENOENT";
     appendLog(
@@ -16878,7 +17061,7 @@ function withPrivateIndex(repoRoot, run) {
   try {
     return run(copy ? privateIndexEnv(copy) : null);
   } finally {
-    if (tmpDir) fs18.rmSync(tmpDir, { recursive: true, force: true });
+    if (tmpDir) fs19.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 function privateIndexEnv(indexPath) {
@@ -17295,8 +17478,8 @@ function filterOmittedFilesFromTree(repoRoot, treeSha, options = {}) {
   options.omittedFiles?.push(...omittedFiles);
   return timeCaptureStage(repoRoot, "tracked-tree-filter", () => {
     if (omittedFiles.length === 0) return treeSha;
-    const tmpIndex = path17.join(
-      os7.tmpdir(),
+    const tmpIndex = path18.join(
+      os8.tmpdir(),
       `hillclimb-filter-${Date.now()}-${process.pid}`
     );
     const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -17310,7 +17493,7 @@ function filterOmittedFilesFromTree(repoRoot, treeSha, options = {}) {
       return gitWithEnv(repoRoot, ["write-tree"], env);
     } finally {
       try {
-        fs18.unlinkSync(tmpIndex);
+        fs19.unlinkSync(tmpIndex);
       } catch {
       }
     }
@@ -17335,8 +17518,8 @@ function buildUntrackedTree(repoRoot, options = {}, attempt = 1) {
       if (!relPath) continue;
       candidates++;
       try {
-        const absPath = path17.join(repoRoot, relPath);
-        const stat = fs18.lstatSync(absPath);
+        const absPath = path18.join(repoRoot, relPath);
+        const stat = fs19.lstatSync(absPath);
         const reason = classifyOmission(
           relPath,
           stat.size,
@@ -17367,11 +17550,11 @@ function buildUntrackedTree(repoRoot, options = {}, attempt = 1) {
     `git-traces: untracked inventory (repo=${repoRoot}, candidates=${candidates}, kept=${kept.length}, keptBytes=${keptBytes}, omitted=${omitted}, omittedBytes=${omittedBytes}, skipped=${skipped})`
   );
   if (kept.length === 0) return null;
-  const tmpDir = fs18.mkdtempSync(path17.join(os7.tmpdir(), "hillclimb-untracked-"));
+  const tmpDir = fs19.mkdtempSync(path18.join(os8.tmpdir(), "hillclimb-untracked-"));
   const env = {
     ...process.env,
     LC_ALL: "C",
-    GIT_INDEX_FILE: path17.join(tmpDir, "index")
+    GIT_INDEX_FILE: path18.join(tmpDir, "index")
   };
   try {
     timeCaptureStage(
@@ -17379,7 +17562,11 @@ function buildUntrackedTree(repoRoot, options = {}, attempt = 1) {
       "untracked-hash-and-index",
       () => gitBuffer(repoRoot, ["update-index", "--add", "-z", "--stdin"], {
         input: `${kept.join("\0")}\0`,
-        env
+        env,
+        timeoutMs: resolveGitCommandTimeoutMs(
+          DEFAULT_UNTRACKED_INDEX_TIMEOUT_MS
+        ),
+        diagnostics: { stage: "untracked-hash-and-index" }
       })
     );
     return timeCaptureStage(
@@ -17389,8 +17576,7 @@ function buildUntrackedTree(repoRoot, options = {}, attempt = 1) {
     );
   } catch (err) {
     const failure = err;
-    if (attempt !== 1 || failure.gitExitStatus !== 128 || !failure.gitStderr?.includes("does not exist and --remove not passed"))
-      throw err;
+    if (attempt !== 1 || !failure.isGitMissingWorktreeFile) throw err;
     appendLog(
       "warn",
       `git-traces: retrying untracked capture after files disappeared (repo=${repoRoot}, attempt=${attempt}, maxAttempts=2)`
@@ -17399,7 +17585,7 @@ function buildUntrackedTree(repoRoot, options = {}, attempt = 1) {
     return buildUntrackedTree(repoRoot, options, attempt + 1);
   } finally {
     try {
-      fs18.rmSync(tmpDir, { recursive: true, force: true });
+      fs19.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -17470,8 +17656,8 @@ function mergeSnapshotTrees(repoRoot, filteredTrackedTree, untrackedTree) {
   if (!untrackedTree || untrackedTree === EMPTY_TREE_SHA)
     return filteredTrackedTree;
   if (filteredTrackedTree === EMPTY_TREE_SHA) return untrackedTree;
-  const tmpIndex = path17.join(
-    os7.tmpdir(),
+  const tmpIndex = path18.join(
+    os8.tmpdir(),
     `hillclimb-index-${Date.now()}-${process.pid}`
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -17499,7 +17685,7 @@ function mergeSnapshotTrees(repoRoot, filteredTrackedTree, untrackedTree) {
     );
   } finally {
     try {
-      fs18.unlinkSync(tmpIndex);
+      fs19.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -17514,19 +17700,26 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
   pinRef(repoRoot, orphanRef, orphanCommit);
   let tmpDir;
   try {
-    tmpDir = fs18.mkdtempSync(
-      path17.join(os7.tmpdir(), `hillclimb-bundle-${process.pid}-`)
+    tmpDir = fs19.mkdtempSync(
+      path18.join(os8.tmpdir(), `hillclimb-bundle-${process.pid}-`)
     );
-    const tmpFile = path17.join(tmpDir, "baseline.bundle");
+    const tmpFile = path18.join(tmpDir, "baseline.bundle");
     timeCaptureStage(
       repoRoot,
       "bundle-create",
       () => gitBuffer(repoRoot, ["bundle", "create", tmpFile, orphanRef], {
         timeoutMs: resolveGitCommandTimeoutMs(DEFAULT_BUNDLE_TIMEOUT_MS),
-        killProcessGroup: true
+        killProcessGroup: true,
+        diagnostics: { stage: "bundle-create", bundleFile: tmpFile }
       })
     );
-    const bundle = fs18.readFileSync(tmpFile);
+    const bytes = fs19.statSync(tmpFile).size;
+    if (bytes > MAX_BASELINE_BUNDLE_BYTES) {
+      throw new Error(
+        `Git baseline bundle exceeds the upload limit (bytes=${bytes}, maxBytes=${MAX_BASELINE_BUNDLE_BYTES}); capture retained`
+      );
+    }
+    const bundle = fs19.readFileSync(tmpFile);
     appendLog(
       "info",
       `git-traces: bundle inventory (repo=${repoRoot}, bytes=${bundle.length})`
@@ -17534,14 +17727,28 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
     return bundle;
   } finally {
     try {
-      if (tmpDir) fs18.rmSync(tmpDir, { recursive: true, force: true });
+      if (tmpDir) fs19.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
     deleteRef(repoRoot, orphanRef);
   }
 }
 var MAX_PATCH_GZ_BYTES = 500 * 1024 * 1024;
-function gitGzipStream(repoRoot, args, maxGzBytes) {
+var MAX_PATCH_RAW_BYTES = 1023 * 1024 * 1024 - 1;
+var GitPatchTooLargeError = class extends Error {
+  constructor(rawBytes, maxRawBytes) {
+    super(
+      `git diff raw output exceeded the ${maxRawBytes}-byte replay limit (observedBytes=${rawBytes}); a new baseline is required`
+    );
+    this.rawBytes = rawBytes;
+    this.maxRawBytes = maxRawBytes;
+    this.name = "GitPatchTooLargeError";
+  }
+};
+function resolveMaxPatchRawBytes(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? Math.min(value, MAX_PATCH_RAW_BYTES) : MAX_PATCH_RAW_BYTES;
+}
+function gitGzipStream(repoRoot, args, maxGzBytes, maxRawBytes) {
   return new Promise((resolve, reject) => {
     const started = Date.now();
     const child = spawn2("git", args, {
@@ -17558,6 +17765,7 @@ function gitGzipStream(repoRoot, args, maxGzBytes) {
     let settled = false;
     let timedOut = false;
     let overflowed = false;
+    let rawOverflowed = false;
     let streamError = null;
     let exitCode = null;
     let exitSignal = null;
@@ -17584,6 +17792,8 @@ function gitGzipStream(repoRoot, args, maxGzBytes) {
         );
         probeObjectStore(repoRoot, "timeout", wrapped.gitStderr, args);
         reject(wrapped);
+      } else if (rawOverflowed) {
+        reject(new GitPatchTooLargeError(rawBytes, maxRawBytes));
       } else if (overflowed) {
         reject(
           createGitError(args, { code: "ENOBUFS", maxBufferBytes: maxGzBytes })
@@ -17602,8 +17812,22 @@ function gitGzipStream(repoRoot, args, maxGzBytes) {
         resolve({ gz: Buffer.concat(gzChunks), rawBytes });
       }
     };
+    const stopForOverflow = () => {
+      child.stdout.unpipe(gzip);
+      child.stdout.resume();
+      child.kill("SIGTERM");
+      gzip.destroy();
+      gzChunks.length = 0;
+      gzipDone = true;
+      finish();
+    };
     child.stdout.on("data", (chunk) => {
+      if (rawOverflowed || overflowed) return;
       rawBytes += chunk.length;
+      if (rawBytes > maxRawBytes) {
+        rawOverflowed = true;
+        stopForOverflow();
+      }
     });
     child.stdout.on("error", (err) => {
       streamError ??= err;
@@ -17612,17 +17836,11 @@ function gitGzipStream(repoRoot, args, maxGzBytes) {
     });
     child.stdout.pipe(gzip);
     gzip.on("data", (chunk) => {
+      if (rawOverflowed || overflowed) return;
       gzBytes += chunk.length;
       if (gzBytes > maxGzBytes) {
-        if (!overflowed) {
-          overflowed = true;
-          child.stdout.unpipe(gzip);
-          child.stdout.resume();
-          child.kill("SIGTERM");
-          gzip.destroy();
-          gzipDone = true;
-          finish();
-        }
+        overflowed = true;
+        stopForOverflow();
         return;
       }
       gzChunks.push(chunk);
@@ -17632,7 +17850,7 @@ function gitGzipStream(repoRoot, args, maxGzBytes) {
       finish();
     });
     gzip.on("error", (err) => {
-      if (!overflowed) streamError ??= err;
+      if (!overflowed && !rawOverflowed) streamError ??= err;
       gzipDone = true;
       finish();
     });
@@ -17673,7 +17891,8 @@ async function createTreeDiffPatchGz(repoRoot, fromTreeSha, toTreeSha, options =
       const { gz, rawBytes } = await gitGzipStream(
         repoRoot,
         ["diff", "--binary", filteredFromTreeSha, filteredToTreeSha],
-        options.maxPatchGzBytes ?? MAX_PATCH_GZ_BYTES
+        options.maxPatchGzBytes ?? MAX_PATCH_GZ_BYTES,
+        resolveMaxPatchRawBytes(options.maxPatchRawBytes)
       );
       if (rawBytes === 0) return null;
       return gz;
@@ -17753,7 +17972,7 @@ function buildBaselineMetadata(repoRoot, sessionId, tool, baselineSha, cliVersio
       ...omittedFiles.length > 0 ? { omittedFiles } : {}
     },
     author: { name: authorName, email: authorEmail },
-    hostname: os7.hostname(),
+    hostname: os8.hostname(),
     cliVersion,
     commits,
     ...lineage,
@@ -17845,9 +18064,9 @@ function parseCommitFiles(repoRoot, sha) {
         oldPath
       });
     } else {
-      const path28 = parts[parts.length - 1];
-      indexByPath.set(path28, files.length);
-      files.push({ path: path28, status, additions: 0, deletions: 0 });
+      const path29 = parts[parts.length - 1];
+      indexByPath.set(path29, files.length);
+      files.push({ path: path29, status, additions: 0, deletions: 0 });
     }
   }
   for (const line of numstat.split("\n")) {
@@ -17931,11 +18150,11 @@ function countScopedTurnTreeRefs(repoRoot, sessionId, epochPrefix3) {
 
 // src/git-traces/session-state.ts
 import crypto6 from "crypto";
-import fs19 from "fs";
-import os8 from "os";
-import path18 from "path";
+import fs20 from "fs";
+import os9 from "os";
+import path19 from "path";
 var CURRENT_SCHEMA_VERSION3 = 3;
-var DEFAULT_STATE_DIR2 = path18.join(os8.homedir(), ".hillclimb", "git-traces");
+var DEFAULT_STATE_DIR2 = path19.join(os9.homedir(), ".hillclimb", "git-traces");
 var LOCK_RETRIES2 = 120;
 var LOCK_RETRY_DELAY_MS2 = 500;
 var DEFAULT_LIVE_OWNER_MAX_WAIT_MS2 = 10 * 60 * 1e3;
@@ -17960,16 +18179,16 @@ function stateDir3() {
 }
 function stateFileForRepo(repoRoot, tool, sessionId) {
   const hash = crypto6.createHash("sha256").update(
-    sessionId ? `${path18.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path18.resolve(repoRoot)}\0${tool}`
+    sessionId ? `${path19.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path19.resolve(repoRoot)}\0${tool}`
   ).digest("hex").slice(0, 16);
-  return path18.join(stateDir3(), `${hash}.json`);
+  return path19.join(stateDir3(), `${hash}.json`);
 }
 function lockFileForRepo(repoRoot, tool, sessionId) {
   return `${stateFileForRepo(repoRoot, tool, sessionId)}.lock`;
 }
 async function readStateFile(file) {
   try {
-    const raw = await fs19.promises.readFile(file, "utf-8");
+    const raw = await fs20.promises.readFile(file, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION3) {
       return null;
@@ -17983,7 +18202,7 @@ async function readStoredStateFile(file) {
   const state = await readStateFile(file);
   if (!state) return null;
   try {
-    return { state, mtimeMs: (await fs19.promises.stat(file)).mtimeMs };
+    return { state, mtimeMs: (await fs20.promises.stat(file)).mtimeMs };
   } catch {
     return null;
   }
@@ -17991,26 +18210,26 @@ async function readStoredStateFile(file) {
 async function listScopedSessionStates(repoRoot, tool) {
   let entries;
   try {
-    entries = await fs19.promises.readdir(stateDir3(), { withFileTypes: true });
+    entries = await fs20.promises.readdir(stateDir3(), { withFileTypes: true });
   } catch {
     return [];
   }
   const states = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const file = path18.join(stateDir3(), entry.name);
+    const file = path19.join(stateDir3(), entry.name);
     const state = await readStateFile(file);
     if (!state) continue;
     if (typeof state.repoRoot !== "string" || typeof state.sessionId !== "string") {
       continue;
     }
-    if (path18.resolve(state.repoRoot) !== path18.resolve(repoRoot)) continue;
-    if (path18.resolve(file) !== path18.resolve(stateFileForRepo(repoRoot, tool, state.sessionId))) {
+    if (path19.resolve(state.repoRoot) !== path19.resolve(repoRoot)) continue;
+    if (path19.resolve(file) !== path19.resolve(stateFileForRepo(repoRoot, tool, state.sessionId))) {
       continue;
     }
     let mtimeMs = 0;
     try {
-      mtimeMs = (await fs19.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs20.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -18021,26 +18240,26 @@ async function listScopedSessionStates(repoRoot, tool) {
 async function listSessionStatesForSession(tool, sessionId) {
   let entries;
   try {
-    entries = await fs19.promises.readdir(stateDir3(), { withFileTypes: true });
+    entries = await fs20.promises.readdir(stateDir3(), { withFileTypes: true });
   } catch {
     return [];
   }
   const states = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const file = path18.join(stateDir3(), entry.name);
+    const file = path19.join(stateDir3(), entry.name);
     const state = await readStateFile(file);
     if (!state) continue;
     if (typeof state.repoRoot !== "string" || typeof state.sessionId !== "string") {
       continue;
     }
     if (state.sessionId !== sessionId) continue;
-    if (path18.resolve(file) !== path18.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
+    if (path19.resolve(file) !== path19.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
       continue;
     }
     let mtimeMs = 0;
     try {
-      mtimeMs = (await fs19.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs20.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -18089,17 +18308,17 @@ async function writeLegacySessionState(state, tool) {
   );
 }
 async function writeStateFile(file, state) {
-  await fs19.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
+  await fs20.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   const tmp = `${file}.tmp`;
-  await fs19.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+  await fs20.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
     mode: 384
   });
-  await fs19.promises.rename(tmp, file);
+  await fs20.promises.rename(tmp, file);
 }
 async function touchSessionState(repoRoot, tool, sessionId) {
   const now = /* @__PURE__ */ new Date();
   try {
-    await fs19.promises.utimes(
+    await fs20.promises.utimes(
       stateFileForRepo(repoRoot, tool, sessionId),
       now,
       now
@@ -18109,7 +18328,7 @@ async function touchSessionState(repoRoot, tool, sessionId) {
 }
 async function statSessionStateMtime(repoRoot, tool, sessionId) {
   try {
-    const stat = await fs19.promises.stat(
+    const stat = await fs20.promises.stat(
       stateFileForRepo(repoRoot, tool, sessionId)
     );
     return stat.mtimeMs;
@@ -18119,7 +18338,7 @@ async function statSessionStateMtime(repoRoot, tool, sessionId) {
 }
 async function deleteStateFile(file) {
   try {
-    await fs19.promises.unlink(file);
+    await fs20.promises.unlink(file);
   } catch {
   }
 }
@@ -18158,7 +18377,7 @@ async function acquireLock3(repoRoot, tool, sessionId, retries, delayMs, options
 }
 async function acquireLockWithoutTiming(repoRoot, tool, sessionId, retries, delayMs, options = {}) {
   const lockPath = lockFileForRepo(repoRoot, tool, sessionId);
-  await fs19.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
+  await fs20.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   const bounded = retries !== void 0 || delayMs !== void 0;
   const attempts = retries ?? LOCK_RETRIES2;
   const delay = delayMs ?? LOCK_RETRY_DELAY_MS2;
@@ -18168,9 +18387,9 @@ async function acquireLockWithoutTiming(repoRoot, tool, sessionId, retries, dela
   let extensionLogged = false;
   for (let i = 0; ; i++) {
     try {
-      const fd = await fs19.promises.open(
+      const fd = await fs20.promises.open(
         lockPath,
-        fs19.constants.O_CREAT | fs19.constants.O_EXCL | fs19.constants.O_WRONLY
+        fs20.constants.O_CREAT | fs20.constants.O_EXCL | fs20.constants.O_WRONLY
       );
       await fd.write(String(process.pid));
       await fd.close();
@@ -18179,7 +18398,7 @@ async function acquireLockWithoutTiming(repoRoot, tool, sessionId, retries, dela
       if (err.code !== "EEXIST") throw err;
       let regularLockFile = false;
       try {
-        regularLockFile = (await fs19.promises.lstat(lockPath)).isFile();
+        regularLockFile = (await fs20.promises.lstat(lockPath)).isFile();
       } catch (statErr) {
         if (statErr.code === "ENOENT") {
           i--;
@@ -18241,21 +18460,21 @@ async function acquireLockWithoutTiming(repoRoot, tool, sessionId, retries, dela
 }
 async function releaseLock3(repoRoot, tool, sessionId) {
   try {
-    await fs19.promises.unlink(lockFileForRepo(repoRoot, tool, sessionId));
+    await fs20.promises.unlink(lockFileForRepo(repoRoot, tool, sessionId));
   } catch {
   }
 }
 async function sweepStaleLockFiles(ttlMs = STALE_LOCK_TTL_MS3, now = Date.now()) {
   let entries;
   try {
-    entries = await fs19.promises.readdir(stateDir3(), { withFileTypes: true });
+    entries = await fs20.promises.readdir(stateDir3(), { withFileTypes: true });
   } catch {
     return 0;
   }
   let removed = 0;
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".lock")) continue;
-    const file = path18.join(stateDir3(), entry.name);
+    const file = path19.join(stateDir3(), entry.name);
     if (await reapLockIfStale(file, {
       maxAgeMs: ttlMs,
       preserveLiveOwner: true,
@@ -18270,6 +18489,8 @@ async function sweepStaleLockFiles(ttlMs = STALE_LOCK_TTL_MS3, now = Date.now())
 // src/git-traces/pending-captures.ts
 var MAX_CAPTURES = 128;
 var MAX_PENDING_BYTES2 = 2 * 1024 * 1024 * 1024;
+var MAX_OVERSIZED_CAPTURE_BYTES = 4 * 1024 * 1024 * 1024;
+var MAX_OVERSIZED_ARTIFACT_BYTES = 4 * 1024 * 1024 * 1024;
 var PendingCaptureLimitError = class extends Error {
 };
 var STRANDED_MIN_AGE_MS = 10 * 60 * 1e3;
@@ -18317,12 +18538,12 @@ function withPendingCapture(record, work) {
   return activeCapture.run({ record, save: () => saveCapture(record) }, work);
 }
 function queueDirectory(repoRoot, tool, sessionId) {
-  const stateDir4 = process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? path19.join(os9.homedir(), ".hillclimb", "git-traces");
-  const key = crypto7.createHash("sha256").update(`${path19.resolve(repoRoot)}\0${tool}\0${sessionId}`).digest("hex");
-  return path19.join(stateDir4, "pending-v1", key);
+  const stateDir4 = process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? path20.join(os10.homedir(), ".hillclimb", "git-traces");
+  const key = crypto7.createHash("sha256").update(`${path20.resolve(repoRoot)}\0${tool}\0${sessionId}`).digest("hex");
+  return path20.join(stateDir4, "pending-v1", key);
 }
 function captureDirectory(record) {
-  return path19.join(
+  return path20.join(
     queueDirectory(record.repoRoot, record.tool, record.sessionId),
     record.id
   );
@@ -18330,20 +18551,20 @@ function captureDirectory(record) {
 function writeDurable(file, body) {
   const temporary = `${file}.${process.pid}.tmp`;
   try {
-    const descriptor = fs20.openSync(temporary, "w", 384);
+    const descriptor = fs21.openSync(temporary, "w", 384);
     try {
-      fs20.writeFileSync(descriptor, body);
-      fs20.fsyncSync(descriptor);
+      fs21.writeFileSync(descriptor, body);
+      fs21.fsyncSync(descriptor);
     } finally {
-      fs20.closeSync(descriptor);
+      fs21.closeSync(descriptor);
     }
-    fs20.renameSync(temporary, file);
+    fs21.renameSync(temporary, file);
     try {
-      const directory = fs20.openSync(path19.dirname(file), "r");
+      const directory = fs21.openSync(path20.dirname(file), "r");
       try {
-        fs20.fsyncSync(directory);
+        fs21.fsyncSync(directory);
       } finally {
-        fs20.closeSync(directory);
+        fs21.closeSync(directory);
       }
     } catch (err) {
       if (!["EINVAL", "ENOTSUP", "EBADF", "EPERM", "EISDIR"].includes(
@@ -18352,7 +18573,7 @@ function writeDurable(file, body) {
         throw err;
     }
   } finally {
-    if (fs20.existsSync(temporary)) fs20.unlinkSync(temporary);
+    if (fs21.existsSync(temporary)) fs21.unlinkSync(temporary);
   }
 }
 function saveCapture(record) {
@@ -18363,7 +18584,7 @@ function saveCapture(record) {
   let status = "failed";
   try {
     writeDurable(
-      path19.join(captureDirectory(record), "capture.json"),
+      path20.join(captureDirectory(record), "capture.json"),
       JSON.stringify(record)
     );
     status = "ok";
@@ -18375,7 +18596,7 @@ function listPendingCaptures2(repoRoot, tool, sessionId) {
   const directory = queueDirectory(repoRoot, tool, sessionId);
   let entries;
   try {
-    entries = fs20.readdirSync(directory, { withFileTypes: true });
+    entries = fs21.readdirSync(directory, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -18383,10 +18604,10 @@ function listPendingCaptures2(repoRoot, tool, sessionId) {
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || !/^[0-9a-f-]{36}$/.test(entry.name)) continue;
-    const file = path19.join(directory, entry.name, "capture.json");
-    if (!fs20.existsSync(file)) continue;
+    const file = path20.join(directory, entry.name, "capture.json");
+    if (!fs21.existsSync(file)) continue;
     const record = JSON.parse(
-      fs20.readFileSync(file, "utf-8")
+      fs21.readFileSync(file, "utf-8")
     );
     if (record.version !== 1 || record.id !== entry.name || record.repoRoot !== repoRoot || record.tool !== tool || record.sessionId !== sessionId) {
       throw new Error(`Invalid pending Git capture: ${file}`);
@@ -18399,13 +18620,13 @@ function hasPendingCaptures(repoRoot, tool, sessionId) {
   return listPendingCaptures2(repoRoot, tool, sessionId).length > 0;
 }
 function listPendingQueues() {
-  const root = path19.join(
-    process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? path19.join(os9.homedir(), ".hillclimb", "git-traces"),
+  const root = path20.join(
+    process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? path20.join(os10.homedir(), ".hillclimb", "git-traces"),
     "pending-v1"
   );
   let queueDirs;
   try {
-    queueDirs = fs20.readdirSync(root, { withFileTypes: true });
+    queueDirs = fs21.readdirSync(root, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -18413,15 +18634,15 @@ function listPendingQueues() {
   const queues = [];
   for (const queueDir of queueDirs) {
     if (!queueDir.isDirectory()) continue;
-    const directory = path19.join(root, queueDir.name);
+    const directory = path20.join(root, queueDir.name);
     let identity = null;
     try {
-      for (const entry of fs20.readdirSync(directory, { withFileTypes: true })) {
+      for (const entry of fs21.readdirSync(directory, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const file = path19.join(directory, entry.name, "capture.json");
-        if (!fs20.existsSync(file)) continue;
+        const file = path20.join(directory, entry.name, "capture.json");
+        if (!fs21.existsSync(file)) continue;
         identity = JSON.parse(
-          fs20.readFileSync(file, "utf-8")
+          fs21.readFileSync(file, "utf-8")
         );
         break;
       }
@@ -18454,15 +18675,15 @@ function noteReplayFailure(record, error, now = Date.now()) {
 }
 function queueDiskBytes(directory) {
   let diskBytes = 0;
-  if (fs20.existsSync(directory)) {
-    for (const entry of fs20.readdirSync(directory, { withFileTypes: true })) {
+  if (fs21.existsSync(directory)) {
+    for (const entry of fs21.readdirSync(directory, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      for (const file of fs20.readdirSync(path19.join(directory, entry.name), {
+      for (const file of fs21.readdirSync(path20.join(directory, entry.name), {
         withFileTypes: true
       })) {
         if (file.isFile())
-          diskBytes += fs20.statSync(
-            path19.join(directory, entry.name, file.name)
+          diskBytes += fs21.statSync(
+            path20.join(directory, entry.name, file.name)
           ).size;
       }
     }
@@ -18478,10 +18699,15 @@ function pendingBytes(records) {
   return queueDiskBytes(
     queueDirectory(first.repoRoot, first.tool, first.sessionId)
   ) + records.reduce(
-    (sum, record) => sum + chargedBytes(record) + (fs20.existsSync(path19.join(captureDirectory(record), "capture.json")) ? 0 : Buffer.byteLength(JSON.stringify(record))),
+    (sum, record) => sum + chargedBytes(record) + (fs21.existsSync(path20.join(captureDirectory(record), "capture.json")) ? 0 : Buffer.byteLength(JSON.stringify(record))),
     0
   );
 }
+function artifactByteLimit(records, captureId) {
+  const record = records.length === 1 ? records[0] : void 0;
+  const retained = record ? chargedBytes(record) : 0;
+  return record?.id === captureId && record.oversized === true && retained >= 0 && retained <= MAX_OVERSIZED_CAPTURE_BYTES ? retained + MAX_OVERSIZED_ARTIFACT_BYTES : MAX_PENDING_BYTES2;
+}
 function warnMissingBase(repoRoot, base) {
   appendLog(
     "warn",
@@ -18636,14 +18862,19 @@ function storePendingCapture(params) {
     const pendingBefore = queueDiskBytes(
       queueDirectory(params.repoRoot, params.tool, params.sessionId)
     ) + existing.reduce((sum, item) => sum + chargedBytes(item), 0);
-    const incomingBytes = retainedBytes + Buffer.byteLength(JSON.stringify(record));
-    if (existing.length >= MAX_CAPTURES || pendingBefore + incomingBytes > MAX_PENDING_BYTES2) {
+    let incomingBytes = retainedBytes + Buffer.byteLength(JSON.stringify(record));
+    if (existing.length === 0 && pendingBefore === 0 && incomingBytes > MAX_PENDING_BYTES2) {
+      record.oversized = true;
+      incomingBytes = retainedBytes + Buffer.byteLength(JSON.stringify(record));
+    }
+    const maxBytes = record.oversized ? MAX_OVERSIZED_CAPTURE_BYTES : MAX_PENDING_BYTES2;
+    if (existing.some((item) => item.oversized === true) || existing.length >= MAX_CAPTURES || pendingBefore + incomingBytes > maxBytes) {
       throw new PendingCaptureLimitError(
-        `Pending Git capture limit reached (count=${existing.length}, maxCount=${MAX_CAPTURES}, pendingBytes=${pendingBefore}, incomingBytes=${incomingBytes}, retainedBytes=${retainedBytes}, maxBytes=${MAX_PENDING_BYTES2}); existing captures retained`
+        `Pending Git capture limit reached (count=${existing.length}, maxCount=${MAX_CAPTURES}, pendingBytes=${pendingBefore}, incomingBytes=${incomingBytes}, retainedBytes=${retainedBytes}, maxBytes=${maxBytes}); existing captures retained`
       );
     }
     const directory = captureDirectory(record);
-    fs20.mkdirSync(directory, { recursive: true, mode: 448 });
+    fs21.mkdirSync(directory, { recursive: true, mode: 448 });
     const refRoot = `refs/hillclimb/pending-v1/${record.id}`;
     let published = false;
     try {
@@ -18681,12 +18912,12 @@ function storePendingCapture(params) {
       durableDetails = `capture=${record.id}, durableCapturedAt=${durableCapturedAt}`;
       appendLog(
         "info",
-        `git-traces: capture queued (repo=${record.repoRoot}, session=${record.sessionId}, capture=${record.id}, recordedAt=${record.recordedAt}, captureStartedAt=${record.captureStartedAt}, capturedAt=${record.capturedAt}, sourceCapturedAt=${record.capturedAt}, durableCapturedAt=${durableCapturedAt}, pending=${existing.length + 1}, oldestPendingAgeMs=${Date.now() - (existing[0]?.capturedAt ?? record.capturedAt)}, retainedBytes=${record.retainedBytes}, pendingBytes=${pendingBefore + incomingBytes})`
+        `git-traces: capture queued (repo=${record.repoRoot}, session=${record.sessionId}, capture=${record.id}, recordedAt=${record.recordedAt}, captureStartedAt=${record.captureStartedAt}, capturedAt=${record.capturedAt}, sourceCapturedAt=${record.capturedAt}, durableCapturedAt=${durableCapturedAt}, pending=${existing.length + 1}, oldestPendingAgeMs=${Date.now() - (existing[0]?.capturedAt ?? record.capturedAt)}, retainedBytes=${record.retainedBytes}, pendingBytes=${pendingBefore + incomingBytes}, oversized=${record.oversized === true})`
       );
       return record;
     } finally {
       if (!published) {
-        fs20.rmSync(directory, { recursive: true, force: true });
+        fs21.rmSync(directory, { recursive: true, force: true });
         for (const label of [
           "snapshot",
           "tree",
@@ -18717,7 +18948,7 @@ async function preparePendingUpload(context, contributionId, filename, buffer) {
       let status = "failed";
       try {
         if (saved) {
-          const bytes = fs20.readFileSync(path19.join(directory, saved.file));
+          const bytes = fs21.readFileSync(path20.join(directory, saved.file));
           if (bytes.length !== saved.bytes || crypto7.createHash("sha256").update(bytes).digest("hex") !== saved.sha256) {
             throw new Error(
               `Pending Git artifact is corrupt: ${saved.file}; capture retained`
@@ -18731,23 +18962,35 @@ async function preparePendingUpload(context, contributionId, filename, buffer) {
           context.record.tool,
           context.record.sessionId
         );
-        if (pendingBytes(records) + buffer.byteLength > MAX_PENDING_BYTES2) {
-          throw new Error(
-            `Pending Git artifact byte limit reached (${MAX_PENDING_BYTES2}); capture retained`
-          );
-        }
         const file = `${crypto7.createHash("sha256").update(key).digest("hex")}.artifact`;
-        writeDurable(path19.join(directory, file), buffer);
-        context.record.uploads[key] = {
+        const upload = {
           file,
           bytes: buffer.byteLength,
           sha256: crypto7.createHash("sha256").update(buffer).digest("hex")
         };
+        const nextRecordBytes = Buffer.byteLength(
+          JSON.stringify({
+            ...context.record,
+            uploads: { ...context.record.uploads, [key]: upload }
+          })
+        );
+        const recordGrowth = Math.max(
+          0,
+          nextRecordBytes - fs21.statSync(path20.join(directory, "capture.json")).size
+        );
+        const maxBytes = artifactByteLimit(records, context.record.id);
+        if (pendingBytes(records) + buffer.byteLength + recordGrowth > maxBytes) {
+          throw new Error(
+            `Pending Git artifact byte limit reached (${maxBytes}); capture retained`
+          );
+        }
+        writeDurable(path20.join(directory, file), buffer);
+        context.record.uploads[key] = upload;
         try {
           context.save();
         } catch (err) {
           delete context.record.uploads[key];
-          fs20.rmSync(path19.join(directory, file), { force: true });
+          fs21.rmSync(path20.join(directory, file), { force: true });
           throw err;
         }
         status = "ok";
@@ -18779,8 +19022,8 @@ function readPreparedCaptureArtifact(context, filename, input) {
       throw new Error(
         `Prepared Git artifact input changed: ${filename}; capture retained`
       );
-    const bytes = fs20.readFileSync(
-      path19.join(captureDirectory(context.record), saved.file)
+    const bytes = fs21.readFileSync(
+      path20.join(captureDirectory(context.record), saved.file)
     );
     if (bytes.length !== saved.bytes || crypto7.createHash("sha256").update(bytes).digest("hex") !== saved.sha256)
       throw new Error(
@@ -18799,7 +19042,7 @@ function completePendingCapture(record) {
 function removeCompletedCapture(record) {
   if (!record.completed)
     throw new Error("Cannot remove an unacknowledged Git capture");
-  fs20.rmSync(captureDirectory(record), { recursive: true, force: true });
+  fs21.rmSync(captureDirectory(record), { recursive: true, force: true });
   for (const label of ["snapshot", "tree", "head", "baseline", "previous"]) {
     deleteRef(
       record.repoRoot,
@@ -18872,7 +19115,7 @@ async function uploadArtifact(client, contributionId, filename, mimeType, buffer
 }
 
 // package.json
-var version = "0.9.13";
+var version = "0.9.15";
 
 // src/version.ts
 var CLI_VERSION = version;
@@ -18896,7 +19139,7 @@ function lineHasAssistant(line) {
   return line.includes('"type":"assistant"') || line.includes('"role":"assistant"') || line.includes('"type":"assistant.');
 }
 async function hasAssistantMessage(transcriptPath) {
-  const stream = fs21.createReadStream(transcriptPath, { encoding: "utf-8" });
+  const stream = fs22.createReadStream(transcriptPath, { encoding: "utf-8" });
   let buffer = "";
   try {
     for await (const chunk of stream) {
@@ -18983,8 +19226,8 @@ function resolveCursorTranscriptPath(payload) {
   const workspace = payload.workspace_roots?.[0];
   if (!id || !workspace) return void 0;
   const encoded = workspace.replace(/^\//, "").replace(/\//g, "-");
-  return path20.join(
-    os10.homedir(),
+  return path21.join(
+    os11.homedir(),
     ".cursor",
     "projects",
     encoded,
@@ -19039,14 +19282,14 @@ async function sweepClaudeSubagentTranscripts(payload) {
   const cwd = resolveHookCwd(payload);
   if (!parentSessionId || !cwd || !payload.transcript_path) return;
   try {
-    const directory = path20.join(
-      path20.dirname(path20.resolve(payload.transcript_path)),
+    const directory = path21.join(
+      path21.dirname(path21.resolve(payload.transcript_path)),
       parentSessionId,
       "subagents"
     );
     let names;
     try {
-      names = await fs21.promises.readdir(directory);
+      names = await fs22.promises.readdir(directory);
     } catch (err) {
       if (err.code === "ENOENT") return;
       throw err;
@@ -19055,12 +19298,12 @@ async function sweepClaudeSubagentTranscripts(payload) {
     for (const name of names) {
       const match = /^agent-([A-Za-z0-9_-]+)\.jsonl$/.exec(name);
       if (!match) continue;
-      const file = path20.join(directory, name);
+      const file = path21.join(directory, name);
       try {
         files.push({
           agentId: match[1],
           file,
-          modifiedMs: (await fs21.promises.stat(file)).mtimeMs
+          modifiedMs: (await fs22.promises.stat(file)).mtimeMs
         });
       } catch {
       }
@@ -19226,7 +19469,7 @@ async function sweepCodexForkTranscripts(payload) {
     const parent = await findProjectForCwd(cwd);
     if (!parent) return;
     const registeredRoots = Object.keys((await loadProjects()).projects).map(
-      (root) => path20.resolve(root)
+      (root) => path21.resolve(root)
     );
     const discovery = await discoverCodexForkThreads({
       parentThreadId: parentSessionId,
@@ -19367,9 +19610,9 @@ async function runUploadForSession(payload, options) {
     );
     return "skipped";
   }
-  const transcriptResolved = path20.resolve(transcriptPath);
+  const transcriptResolved = path21.resolve(transcriptPath);
   try {
-    const stat = await fs21.promises.stat(transcriptResolved);
+    const stat = await fs22.promises.stat(transcriptResolved);
     if (!stat.isFile()) {
       appendLog(
         "warn",
@@ -19425,7 +19668,7 @@ function makeTranscriptGroup(repoRoot, sourceTool, transcriptPath, content) {
   };
   return {
     repoPath: repoRoot,
-    label: path20.basename(repoRoot),
+    label: path21.basename(repoRoot),
     files: [sourceFile],
     sourceNames: [sourceTool],
     lastModified: /* @__PURE__ */ new Date()
@@ -19436,7 +19679,7 @@ async function buildRedactChain(repoRoot, capturedSecrets = []) {
     "secret-discovery",
     () => discoverEnvFiles(repoRoot)
   );
-  const envFilePaths = envFileNames.map((n) => path20.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path21.join(repoRoot, n));
   const secretResult = await measureAgentStage(
     "secret-collection",
     () => collectSecrets(repoRoot, envFilePaths, [])
@@ -20085,7 +20328,7 @@ async function uploadSession(args) {
     try {
       raw = await measureAgentStage(
         "transcript-read",
-        () => captured ? Promise.resolve(captured.bytes) : fs21.promises.readFile(transcriptPath)
+        () => captured ? Promise.resolve(captured.bytes) : fs22.promises.readFile(transcriptPath)
       );
     } catch (err) {
       if (err.code === "ERR_FS_FILE_TOO_LARGE") {
@@ -20456,16 +20699,15 @@ import crypto9 from "crypto";
 
 // src/git-traces/handlers.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import fs22 from "fs";
-import path21 from "path";
+import fs23 from "fs";
+import path22 from "path";
 var GIT_TRACES_SLUG = "git-traces";
 var MAX_FORK_SWEEP_THREADS2 = 8;
 var MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
-var MAX_BASELINE_BUNDLE_UPLOAD_BYTES = 1024 * 1024 * 1024;
 var STALE_SCOPED_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
 var REBASELINE_AFTER_DIFF_FAILURES = 2;
 async function withRepoCaptureLock(repoRoot, capture) {
-  const canonicalRoot = fs22.realpathSync(repoRoot);
+  const canonicalRoot = fs23.realpathSync(repoRoot);
   await acquireLock3(canonicalRoot, "snapshot-index-v1", null);
   try {
     return capture();
@@ -20523,7 +20765,7 @@ var PendingQueueConflictError = class extends Error {
 async function loadConfiguredRepos() {
   const file = await loadProjects();
   return Object.entries(file.projects).map(([repoRoot, config]) => ({
-    repoRoot: path21.resolve(repoRoot),
+    repoRoot: path22.resolve(repoRoot),
     config
   })).sort((a, b) => a.repoRoot.localeCompare(b.repoRoot));
 }
@@ -20541,12 +20783,12 @@ async function configuredReposFor(trigger) {
   return repos;
 }
 async function propagateCodexHooks(parentRoot, worktreeRoot) {
-  const source = path21.join(parentRoot, ".codex", "hooks.json");
-  const target = path21.join(worktreeRoot, ".codex", "hooks.json");
-  if (fs22.existsSync(target) || !fs22.existsSync(source)) return;
+  const source = path22.join(parentRoot, ".codex", "hooks.json");
+  const target = path22.join(worktreeRoot, ".codex", "hooks.json");
+  if (fs23.existsSync(target) || !fs23.existsSync(source)) return;
   try {
-    fs22.mkdirSync(path21.dirname(target), { recursive: true });
-    fs22.copyFileSync(source, target, fs22.constants.COPYFILE_EXCL);
+    fs23.mkdirSync(path22.dirname(target), { recursive: true });
+    fs23.copyFileSync(source, target, fs23.constants.COPYFILE_EXCL);
   } catch (err) {
     appendLog(
       "warn",
@@ -20568,7 +20810,7 @@ async function propagateCodexHooks(parentRoot, worktreeRoot) {
   }
 }
 function repoLabel(repoRoot) {
-  return path21.basename(repoRoot) || repoRoot;
+  return path22.basename(repoRoot) || repoRoot;
 }
 function resolveCwd2(payload) {
   return resolveHookCwd(payload);
@@ -20606,7 +20848,7 @@ function execGit(cwd, args) {
   }).toString("utf-8").trim();
 }
 function canUploadFile(filename, buffer) {
-  const limit = filename.endsWith("-baseline.bundle") ? MAX_BASELINE_BUNDLE_UPLOAD_BYTES : MAX_UPLOAD_BYTES;
+  const limit = filename.endsWith("-baseline.bundle") ? MAX_BASELINE_BUNDLE_BYTES : MAX_UPLOAD_BYTES;
   if (buffer.byteLength <= limit) return true;
   appendLog(
     "warn",
@@ -21689,6 +21931,75 @@ async function refreshLineageBaseline(params) {
     return false;
   }
 }
+async function uploadLargeCaptureBaseline(params) {
+  const { repo, state, tool, persistState, limits } = params;
+  const pending = currentPendingCapture(repo.repoRoot);
+  if (!pending) return "failed";
+  const client = await loadRepoClient(repo);
+  if (!client) return "skipped";
+  if (state.contributionId === null || !state.baselineUploaded) {
+    const initial = buildInitialBaselineArtifactsForState(
+      repo.repoRoot,
+      tool,
+      state,
+      limits
+    );
+    if (!initial || !canUploadEpochBaselineArtifacts(state.epoch, initial))
+      return "failed";
+    if (!await registerInitialContribution({
+      ...params,
+      client,
+      artifacts: initial
+    }))
+      return "failed";
+  }
+  if (state.contributionId === null) return "failed";
+  const nextEpoch = await reserveEpoch(state, persistState);
+  const artifacts = await openEpoch({
+    repoRoot: repo.repoRoot,
+    client,
+    contributionId: state.contributionId,
+    sessionId: state.sessionId,
+    tool,
+    epoch: nextEpoch,
+    prevHeadSha: state.headSha || null,
+    transitionKind: "initial",
+    startedAt: state.startedAt,
+    limits,
+    lineage: state.codexLineage,
+    previousScan: pending.record.scan,
+    provenance: {
+      recovery: {
+        reason: "patch-too-large",
+        trigger: "stop-diff",
+        detectedAt: new Date(pending.record.capturedAt).toISOString(),
+        abandonedEpoch: state.epoch,
+        abandonedBaselineSha: state.baselineSha,
+        abandonedUploadedTurns: state.turnCount
+      }
+    }
+  });
+  if (!artifacts) return "failed";
+  Object.assign(state, {
+    baselineSha: artifacts.baselineSha,
+    baselineTreeSha: artifacts.baselineTreeSha,
+    lastSnapshotSha: artifacts.baselineSha,
+    lastSnapshotTreeSha: artifacts.baselineTreeSha,
+    epoch: nextEpoch,
+    turnCount: 0,
+    headSha: artifacts.headSha,
+    omittedKeys: artifacts.omittedKeys,
+    omissionScan: artifacts.scan,
+    codexLineageStamped: artifacts.uploadedLineage
+  });
+  delete state.diffFailureCount;
+  await persistState(state);
+  appendLog(
+    "info",
+    `git-traces: large patch captured as baseline (repo=${repo.repoRoot}, session=${state.sessionId}, capture=${pending.record.id}, epoch=${nextEpoch}, tree=${artifacts.baselineTreeSha})`
+  );
+  return "uploaded";
+}
 async function recoverFromWedgedDiff(params) {
   const {
     repo,
@@ -22180,6 +22491,20 @@ async function processStopRepo(repo, tool, sessionId, recordedAt, lineageCheck,
         }
       );
     } catch (err) {
+      if (err instanceof GitPatchTooLargeError) {
+        appendLog(
+          "warn",
+          `git-traces: turn patch exceeds Git apply limit; attempting frozen baseline fallback (repo=${repoRoot}, session=${state.sessionId}, rawBytes=${err.rawBytes}, maxRawBytes=${err.maxRawBytes})`
+        );
+        const outcome = await uploadLargeCaptureBaseline({
+          repo,
+          state,
+          tool,
+          persistState,
+          limits
+        });
+        return outcome === "uploaded" ? await finishSuccessfulStop("uploaded") : outcome;
+      }
       if (isMissingObjectError(err)) {
         logMissingBaselineObjects(repoRoot, state, "stop-diff", err);
         state.diffFailureCount = REBASELINE_AFTER_DIFF_FAILURES;
@@ -22838,7 +23163,7 @@ async function collectStopTargets(tool, sessionId, repos, repoByRoot) {
   let needsLineageCheck = false;
   const storedStates = await listSessionStatesForSession(tool, sessionId);
   for (const { state } of storedStates) {
-    const repo = repoByRoot.get(path21.resolve(state.repoRoot));
+    const repo = repoByRoot.get(path22.resolve(state.repoRoot));
     if (!repo) {
       missingConfig++;
       appendLog(
@@ -22870,7 +23195,7 @@ async function lateInitSkipReason(payload, tool) {
   const transcriptPath = payload.transcript_path;
   if (!transcriptPath) return tool === "codex" ? null : "no-transcript-path";
   try {
-    const stat = await fs22.promises.stat(path21.resolve(transcriptPath));
+    const stat = await fs23.promises.stat(path22.resolve(transcriptPath));
     return stat.isFile() ? null : "transcript-not-a-file";
   } catch {
     return "transcript-missing";
@@ -23079,9 +23404,9 @@ async function handleSessionEnd(payload, tool) {
   if (sessionId) {
     const states = await listSessionStatesForSession(tool, sessionId);
     for (const { state } of states) {
-      const repoRoot = path21.resolve(state.repoRoot);
+      const repoRoot = path22.resolve(state.repoRoot);
       repoRoots.add(repoRoot);
-      const canProcess = repoByRoot.has(repoRoot) || project && path21.resolve(project.repoRoot) === repoRoot;
+      const canProcess = repoByRoot.has(repoRoot) || project && path22.resolve(project.repoRoot) === repoRoot;
       if (canProcess && tool === "codex" && state.codexLineageChecked !== true) {
         needsLineageCheck = true;
       }
@@ -23118,7 +23443,7 @@ async function handleSessionEnd(payload, tool) {
   let rejected = 0;
   const finalCaptures = /* @__PURE__ */ new Map();
   for (const repoRoot of repoRoots) {
-    const repo = repoByRoot.get(path21.resolve(repoRoot)) ?? (project && path21.resolve(project.repoRoot) === path21.resolve(repoRoot) ? { repoRoot: project.repoRoot, config: project.config } : null);
+    const repo = repoByRoot.get(path22.resolve(repoRoot)) ?? (project && path22.resolve(project.repoRoot) === path22.resolve(repoRoot) ? { repoRoot: project.repoRoot, config: project.config } : null);
     if (repo)
       finalCaptures.set(
         repoRoot,
@@ -23126,7 +23451,7 @@ async function handleSessionEnd(payload, tool) {
       );
   }
   for (const repoRoot of repoRoots) {
-    const repo = repoByRoot.get(path21.resolve(repoRoot)) ?? (project && path21.resolve(project.repoRoot) === path21.resolve(repoRoot) ? { repoRoot: project.repoRoot, config: project.config } : null);
+    const repo = repoByRoot.get(path22.resolve(repoRoot)) ?? (project && path22.resolve(project.repoRoot) === path22.resolve(repoRoot) ? { repoRoot: project.repoRoot, config: project.config } : null);
     if (!repo) {
       skipped++;
       appendLog(
@@ -23505,29 +23830,29 @@ ${stack}` : ""}`
 }
 
 // src/outputs/zip.ts
-import fs24 from "fs";
-import path23 from "path";
+import fs25 from "fs";
+import path24 from "path";
 import archiver2 from "archiver";
 
 // src/outputs/downloads.ts
 import { execSync as execSync2 } from "child_process";
-import fs23 from "fs";
-import os11 from "os";
-import path22 from "path";
+import fs24 from "fs";
+import os12 from "os";
+import path23 from "path";
 function getDownloadsFolder() {
-  const home = os11.homedir();
+  const home = os12.homedir();
   if (process.platform === "linux") {
     try {
       const xdgDir = execSync2("xdg-user-dir DOWNLOAD", {
         encoding: "utf-8",
         timeout: 3e3
       }).trim();
-      if (xdgDir && fs23.existsSync(xdgDir)) return xdgDir;
+      if (xdgDir && fs24.existsSync(xdgDir)) return xdgDir;
     } catch {
     }
   }
-  const downloads = path22.join(home, "Downloads");
-  if (fs23.existsSync(downloads)) return downloads;
+  const downloads = path23.join(home, "Downloads");
+  if (fs24.existsSync(downloads)) return downloads;
   return home;
 }
 
@@ -23536,11 +23861,11 @@ function sanitizeFilename(name) {
   return name.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function getUniqueFilename(dir, base, ext) {
-  let candidate = path23.join(dir, `${base}${ext}`);
-  if (!fs24.existsSync(candidate)) return candidate;
+  let candidate = path24.join(dir, `${base}${ext}`);
+  if (!fs25.existsSync(candidate)) return candidate;
   let i = 1;
-  while (fs24.existsSync(candidate)) {
-    candidate = path23.join(dir, `${base}-${i}${ext}`);
+  while (fs25.existsSync(candidate)) {
+    candidate = path24.join(dir, `${base}-${i}${ext}`);
     i++;
   }
   return candidate;
@@ -23550,13 +23875,13 @@ var ZipOutput = class {
   label = "Save as .zip to Downloads";
   async emit(group, options) {
     const downloadsDir = getDownloadsFolder();
-    const repoName = sanitizeFilename(path23.basename(group.repoPath));
+    const repoName = sanitizeFilename(path24.basename(group.repoPath));
     const timeRange = options.timeRange;
     const rangePart = timeRange?.label ?? "all";
     const epochSeconds = Math.floor(Date.now() / 1e3);
     const baseName = `logs-${repoName}-${rangePart}-${epochSeconds}`;
     const outputPath = getUniqueFilename(downloadsDir, baseName, ".zip");
-    const output = fs24.createWriteStream(outputPath);
+    const output = fs25.createWriteStream(outputPath);
     const archive = archiver2("zip", { zlib: { level: 6 } });
     const done = new Promise((resolve, reject) => {
       output.on("close", resolve);
@@ -23750,15 +24075,15 @@ async function confirmExport(group, output) {
 }
 
 // src/sources/claude.ts
-import fs25 from "fs";
-import os12 from "os";
-import path24 from "path";
+import fs26 from "fs";
+import os13 from "os";
+import path25 from "path";
 import readline3 from "readline";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["tool-results"]);
 async function resolveRepoPath(projectDir) {
-  const indexPath = path24.join(projectDir, "sessions-index.json");
+  const indexPath = path25.join(projectDir, "sessions-index.json");
   try {
-    const raw = await fs25.promises.readFile(indexPath, "utf-8");
+    const raw = await fs26.promises.readFile(indexPath, "utf-8");
     const data = JSON.parse(raw);
     if (data.originalPath && typeof data.originalPath === "string") {
       return data.originalPath;
@@ -23766,12 +24091,12 @@ async function resolveRepoPath(projectDir) {
   } catch {
   }
   const cwdCounts = /* @__PURE__ */ new Map();
-  const entries = await fs25.promises.readdir(projectDir, {
+  const entries = await fs26.promises.readdir(projectDir, {
     withFileTypes: true
   });
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-    const cwd = await extractCwdFromJsonl(path24.join(projectDir, entry.name));
+    const cwd = await extractCwdFromJsonl(path25.join(projectDir, entry.name));
     if (cwd) {
       cwdCounts.set(cwd, (cwdCounts.get(cwd) ?? 0) + 1);
     }
@@ -23790,7 +24115,7 @@ async function resolveRepoPath(projectDir) {
   return null;
 }
 async function extractCwdFromJsonl(filePath) {
-  const stream = fs25.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs26.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline3.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -23812,12 +24137,12 @@ async function extractCwdFromJsonl(filePath) {
 async function collectFiles(dir, baseDir, sourceName, repoPath, results) {
   let entries;
   try {
-    entries = await fs25.promises.readdir(dir, { withFileTypes: true });
+    entries = await fs26.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path24.join(dir, entry.name);
+    const fullPath = path25.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
       await collectFiles(fullPath, baseDir, sourceName, repoPath, results);
@@ -23839,19 +24164,19 @@ function fallbackDecode(encodedName) {
 var ClaudeSource = class {
   name = "claude";
   async scan() {
-    const baseDir = path24.join(os12.homedir(), ".claude", "projects");
+    const baseDir = path25.join(os13.homedir(), ".claude", "projects");
     try {
-      await fs25.promises.access(baseDir);
+      await fs26.promises.access(baseDir);
     } catch {
       return [];
     }
-    const projectDirs = await fs25.promises.readdir(baseDir, {
+    const projectDirs = await fs26.promises.readdir(baseDir, {
       withFileTypes: true
     });
     const dirEntries = projectDirs.filter((d) => d.isDirectory());
     const resultArrays = await Promise.all(
       dirEntries.map(async (dir) => {
-        const projectPath = path24.join(baseDir, dir.name);
+        const projectPath = path25.join(baseDir, dir.name);
         const repoPath = await resolveRepoPath(projectPath) ?? fallbackDecode(dir.name);
         const files = [];
         await collectFiles(
@@ -23869,12 +24194,12 @@ var ClaudeSource = class {
 };
 
 // src/sources/codex.ts
-import fs26 from "fs";
-import os13 from "os";
-import path25 from "path";
+import fs27 from "fs";
+import os14 from "os";
+import path26 from "path";
 import readline4 from "readline";
 async function parseSessionMeta2(filePath) {
-  const stream = fs26.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs27.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline4.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -23899,12 +24224,12 @@ async function findJsonlFiles(dir) {
   async function walk(d) {
     let entries;
     try {
-      entries = await fs26.promises.readdir(d, { withFileTypes: true });
+      entries = await fs27.promises.readdir(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path25.join(d, entry.name);
+      const full = path26.join(d, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -23918,11 +24243,11 @@ async function findJsonlFiles(dir) {
 async function loadHistory(historyPath) {
   const map = /* @__PURE__ */ new Map();
   try {
-    await fs26.promises.access(historyPath);
+    await fs27.promises.access(historyPath);
   } catch {
     return map;
   }
-  const stream = fs26.createReadStream(historyPath, { encoding: "utf-8" });
+  const stream = fs27.createReadStream(historyPath, { encoding: "utf-8" });
   const rl = readline4.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -23949,14 +24274,14 @@ async function loadHistory(historyPath) {
 var CodexSource = class {
   name = "codex";
   async scan() {
-    const codexDir = path25.join(os13.homedir(), ".codex");
-    const sessionsDir2 = path25.join(codexDir, "sessions");
+    const codexDir = path26.join(os14.homedir(), ".codex");
+    const sessionsDir2 = path26.join(codexDir, "sessions");
     try {
-      await fs26.promises.access(sessionsDir2);
+      await fs27.promises.access(sessionsDir2);
     } catch {
       return [];
     }
-    const historyPath = path25.join(codexDir, "history.jsonl");
+    const historyPath = path26.join(codexDir, "history.jsonl");
     const [jsonlFiles, historyMap] = await Promise.all([
       findJsonlFiles(sessionsDir2),
       loadHistory(historyPath)
@@ -23979,8 +24304,8 @@ var CodexSource = class {
       });
       const historyLines = historyMap.get(meta.sessionId);
       if (historyLines) {
-        const sessionDir = path25.relative(sessionsDir2, path25.dirname(filePath));
-        const historyAbsPath = path25.join(
+        const sessionDir = path26.relative(sessionsDir2, path26.dirname(filePath));
+        const historyAbsPath = path26.join(
           sessionsDir2,
           sessionDir,
           `history-${meta.sessionId}.jsonl`
@@ -24000,18 +24325,18 @@ var CodexSource = class {
 };
 
 // src/sources/copilotChat.ts
-import fs27 from "fs";
-import os14 from "os";
-import path26 from "path";
+import fs28 from "fs";
+import os15 from "os";
+import path27 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function vsCodeUserDirs() {
-  const home = os14.homedir();
+  const home = os15.homedir();
   const dirs = [
-    path26.join(home, "Library", "Application Support", "Code", "User"),
-    path26.join(home, ".config", "Code", "User")
+    path27.join(home, "Library", "Application Support", "Code", "User"),
+    path27.join(home, ".config", "Code", "User")
   ];
   if (process.env.APPDATA) {
-    dirs.push(path26.join(process.env.APPDATA, "Code", "User"));
+    dirs.push(path27.join(process.env.APPDATA, "Code", "User"));
   }
   return dirs;
 }
@@ -24026,7 +24351,7 @@ function uriToFsPath(uri) {
 async function readWorkspaceFolder(workspaceJsonPath) {
   let raw;
   try {
-    raw = await fs27.promises.readFile(workspaceJsonPath, "utf-8");
+    raw = await fs28.promises.readFile(workspaceJsonPath, "utf-8");
   } catch {
     return null;
   }
@@ -24048,10 +24373,10 @@ var CopilotChatSource = class {
   async scan() {
     const results = [];
     for (const userDir of vsCodeUserDirs()) {
-      const workspaceStorage = path26.join(userDir, "workspaceStorage");
+      const workspaceStorage = path27.join(userDir, "workspaceStorage");
       let hashDirs;
       try {
-        hashDirs = await fs27.promises.readdir(workspaceStorage, {
+        hashDirs = await fs28.promises.readdir(workspaceStorage, {
           withFileTypes: true
         });
       } catch {
@@ -24059,22 +24384,22 @@ var CopilotChatSource = class {
       }
       for (const hash of hashDirs) {
         if (!hash.isDirectory()) continue;
-        const wsRoot = path26.join(workspaceStorage, hash.name);
-        const transcriptsDir = path26.join(
+        const wsRoot = path27.join(workspaceStorage, hash.name);
+        const transcriptsDir = path27.join(
           wsRoot,
           "GitHub.copilot-chat",
           "transcripts"
         );
         let transcriptEntries;
         try {
-          transcriptEntries = await fs27.promises.readdir(transcriptsDir, {
+          transcriptEntries = await fs28.promises.readdir(transcriptsDir, {
             withFileTypes: true
           });
         } catch {
           continue;
         }
         const repoPath = await readWorkspaceFolder(
-          path26.join(wsRoot, "workspace.json")
+          path27.join(wsRoot, "workspace.json")
         );
         if (!repoPath) continue;
         for (const entry of transcriptEntries) {
@@ -24082,7 +24407,7 @@ var CopilotChatSource = class {
           const sessionId = entry.name.slice(0, -".jsonl".length);
           results.push({
             sourceName: this.name,
-            absolutePath: path26.join(transcriptsDir, entry.name),
+            absolutePath: path27.join(transcriptsDir, entry.name),
             repoPath,
             metadata: { sessionId }
           });
@@ -24122,7 +24447,7 @@ function reportRedactionStats(noun, stats) {
 async function filterByTimeRange(group, range) {
   const results = await Promise.all(
     group.files.map(
-      (f) => fs28.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
+      (f) => fs29.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
     )
   );
   const filtered = [];
@@ -24149,10 +24474,10 @@ async function runInteractive() {
   s.start(`Scanning ${source.name} logs...`);
   const allFiles = await source.scan();
   const allGroups = await mergeByRepo(allFiles);
-  const repoRoot = path27.resolve(repo.root);
+  const repoRoot = path28.resolve(repo.root);
   const matching = allGroups.filter((g) => {
-    const resolved = path27.resolve(g.repoPath);
-    return resolved === repoRoot || resolved.startsWith(repoRoot + path27.sep);
+    const resolved = path28.resolve(g.repoPath);
+    return resolved === repoRoot || resolved.startsWith(repoRoot + path28.sep);
   });
   if (matching.length === 0) {
     s.stop(`No ${source.name} logs found for ${repo.name}.`);
@@ -24183,7 +24508,7 @@ async function runInteractive() {
     }
   }
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path27.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path28.join(repoRoot, n));
   const additionalFiles = await promptSecretFiles(envFileNames);
   const secretResult = await collectSecrets(
     repoRoot,