hillclimb 0.9.5 → 0.9.6

package/dist/main.js

@@ -15183,13 +15183,14 @@ import os9 from "os";
 import path19 from "path";
 
 // src/git-traces/git-ops.ts
-import { execFileSync as execFileSync2, spawn as spawn2, spawnSync } from "child_process";
+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 { createGzip } from "zlib";
 
 // src/git-traces/object-store-probe.ts
+import { spawnSync } from "child_process";
 import fs17 from "fs";
 import path16 from "path";
 var probedRepos = /* @__PURE__ */ new Set();
@@ -15197,7 +15198,16 @@ var SAMPLE_FANOUT_DIRS = 8;
 var SAMPLE_READS = 20;
 var SAMPLE_READ_BYTES = 4096;
 var MAX_NAMED_OBJECTS = 3;
-function probeObjectStore(repoRoot, trigger, stderr) {
+var MAX_LOCATE_BLOBS = 2e4;
+var MAX_STALLED_PATH_CHARS = 120;
+var OBJECT_SHA = /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/;
+var gitLimits = {
+  versionMs: 2e3,
+  listMs: 1e4,
+  readMs: 15e3,
+  headMs: 5e3
+};
+function probeObjectStore(repoRoot, trigger, stderr, args = []) {
   if (probedRepos.has(repoRoot)) return;
   probedRepos.add(repoRoot);
   const started = Date.now();
@@ -15226,13 +15236,19 @@ function probeObjectStore(repoRoot, trigger, stderr) {
       `alternates=${fs17.existsSync(path16.join(objectsDir, "info", "alternates")) ? "yes" : "no"}`
     );
     fields.push(...timeSampleReads(sample));
-    for (const sha of namedObjects(stderr)) {
+    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 });
       fields.push(
         stats ? `named=${sha.slice(0, 8)}(size=${stats.size},blocks=${stats.blocks})` : `named=${sha.slice(0, 8)}(no loose file)`
       );
     }
+    fields.push(...gitVersion(repoRoot));
+    locateGitRead(fields, repoRoot, objectsDir, failedTreeish(args), [
+      ...sample.map(sampleSha).filter((sha) => !!sha),
+      ...named
+    ]);
   } catch (err) {
     fields.push(
       `probeError=${err instanceof Error ? err.message : String(err)}`
@@ -15285,6 +15301,7 @@ function timeSampleReads(sample) {
     const readStarted = performance.now();
     try {
       const stats = fs17.statSync(file);
+      if (!stats.isFile()) continue;
       if (stats.size > 0 && stats.blocks === 0) dataless++;
       const fd = fs17.openSync(file, "r");
       try {
@@ -15314,6 +15331,121 @@ function namedObjects(stderr) {
   const shas = new Set(stderr?.match(/\b[0-9a-f]{40}\b/g) ?? []);
   return [...shas].slice(0, MAX_NAMED_OBJECTS);
 }
+function sampleSha(file) {
+  const sha = path16.basename(path16.dirname(file)) + path16.basename(file);
+  return OBJECT_SHA.test(sha) ? sha : null;
+}
+function failedTreeish(args) {
+  for (const arg of args.slice(1).reverse()) {
+    if (OBJECT_SHA.test(arg) || arg.startsWith("refs/")) return arg;
+  }
+  return null;
+}
+function probeGit(repoRoot, args, timeout, input) {
+  return spawnSync("git", args, {
+    cwd: repoRoot,
+    input,
+    timeout,
+    killSignal: "SIGKILL",
+    maxBuffer: 64 * 1024 * 1024,
+    windowsHide: true,
+    // Never prompt or lazily fetch from inside a diagnostic.
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_NO_LAZY_FETCH: "1" }
+  });
+}
+function gitVersion(repoRoot) {
+  const started = performance.now();
+  const result = probeGit(repoRoot, ["--version"], gitLimits.versionMs);
+  const version2 = result.stdout?.toString().trim().replace(/^git version /, "");
+  return [
+    `gitVersion=${result.status === 0 && version2 ? version2 : `unavailable(${result.error ? result.error.code : result.status})`}`,
+    `gitSpawnMs=${(performance.now() - started).toFixed(0)}`
+  ];
+}
+function locateGitRead(fields, repoRoot, objectsDir, treeish, fallback) {
+  let targets = null;
+  if (treeish) {
+    const listed = probeGit(
+      repoRoot,
+      ["ls-tree", "-r", "-z", treeish],
+      gitLimits.listMs
+    );
+    if (listed.status === 0 && listed.stdout) {
+      targets = treeBlobs(listed.stdout.toString());
+      fields.push(
+        `gitReadTarget=tree:${OBJECT_SHA.test(treeish) ? treeish.slice(0, 8) : treeish}`,
+        `treeBlobs=${targets.length}`
+      );
+      targets = targets.slice(0, MAX_LOCATE_BLOBS);
+    } else {
+      fields.push("gitReadTarget=sample", `lsTreeError=${failureText(listed)}`);
+    }
+  } else {
+    fields.push("gitReadTarget=sample");
+  }
+  targets ??= [...new Set(fallback)].map((sha) => ({ sha }));
+  if (targets.length === 0) return;
+  const started = performance.now();
+  const read = probeGit(
+    repoRoot,
+    ["cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"],
+    gitLimits.readMs,
+    `${targets.map((target) => target.sha).join("\n")}
+`
+  );
+  const answered = (read.stdout?.toString() ?? "").split("\n").slice(0, -1);
+  fields.push(
+    `gitRead=${answered.length}/${targets.length}`,
+    `gitReadMs=${(performance.now() - started).toFixed(1)}`,
+    `gitMissing=${answered.filter((line) => line.endsWith(" missing")).length}`
+  );
+  const stalled = targets[answered.length];
+  if (!stalled) return;
+  fields.push(
+    read.error?.code === "ETIMEDOUT" ? `gitReadTimeout=${gitLimits.readMs}` : `gitReadError=${failureText(read)}`,
+    `gitStalledOn=${stalled.sha.slice(0, 8)}`
+  );
+  if (stalled.path)
+    fields.push(
+      `stalledPath=${JSON.stringify(stalled.path.slice(0, MAX_STALLED_PATH_CHARS))}`
+    );
+  const loose = path16.join(
+    objectsDir,
+    stalled.sha.slice(0, 2),
+    stalled.sha.slice(2)
+  );
+  const stats = fs17.statSync(loose, { throwIfNoEntry: false });
+  fields.push(
+    stats ? `stalledLoose=size=${stats.size},blocks=${stats.blocks}` : "stalledLoose=no"
+  );
+  if (stats && process.platform !== "win32") {
+    const headStarted = performance.now();
+    const head = spawnSync("head", ["-c", "4096", loose], {
+      timeout: gitLimits.headMs,
+      killSignal: "SIGKILL"
+    });
+    fields.push(
+      head.error?.code === "ETIMEDOUT" ? `headTimeout=${gitLimits.headMs}` : `headMs=${(performance.now() - headStarted).toFixed(0)}`
+    );
+  }
+}
+function treeBlobs(listing) {
+  const blobs = /* @__PURE__ */ new Map();
+  for (const entry of listing.split("\0")) {
+    const tab = entry.indexOf("	");
+    if (tab < 0) continue;
+    const [, type, sha] = entry.slice(0, tab).split(" ");
+    if (type === "blob" && sha && !blobs.has(sha))
+      blobs.set(sha, entry.slice(tab + 1));
+  }
+  return [...blobs].map(([sha, blobPath]) => ({ sha, path: blobPath }));
+}
+function failureText(result) {
+  const error = result.error;
+  if (error) return error.code ?? error.message;
+  const stderr = result.stderr?.toString().trim().split("\n")[0];
+  return stderr || `exit=${result.status}`;
+}
 
 // src/git-traces/git-ops.ts
 var DEFAULT_GIT_COMMAND_TIMEOUT_MS = 12e4;
@@ -15514,7 +15646,7 @@ function isBinaryBuffer(buffer) {
 }
 function readTreeBlobHead(repoRoot, sha) {
   try {
-    const { stdout } = spawnSync("git", ["cat-file", "blob", sha], {
+    const { stdout } = spawnSync2("git", ["cat-file", "blob", sha], {
       cwd: repoRoot,
       timeout: GIT_COMMAND_TIMEOUT_MS,
       maxBuffer: BINARY_SNIFF_BYTES,
@@ -15634,6 +15766,7 @@ function isGitTimeoutError(err) {
 }
 function gitBuffer(repoRoot, args, options = {}) {
   const timeout = options.timeoutMs ?? EXEC_OPTS.timeout;
+  const detached = options.killProcessGroup && process.platform !== "win32";
   const started = Date.now();
   try {
     return execFileSync2("git", args, {
@@ -15642,15 +15775,25 @@ function gitBuffer(repoRoot, args, options = {}) {
       ...options.input !== void 0 ? { input: options.input } : {},
       stdio: ["pipe", "pipe", "pipe"],
       ...EXEC_OPTS,
-      timeout
+      timeout,
+      // Not in the sync typings, but spawnSync honors it (setsid).
+      ...detached ? { detached: true } : {}
     });
   } catch (err) {
+    const pid = err.pid;
+    if (detached && pid) {
+      try {
+        process.kill(-pid, "SIGKILL");
+      } catch {
+      }
+    }
     const wrapped = createGitError(args, err, timeout, Date.now() - started);
-    if (wrapped.isGitTimeout || wrapped.isGitMissingObject) {
+    if (wrapped.isGitTimeout || wrapped.isGitMissingObject && !options.expectMissingObjects) {
       probeObjectStore(
         repoRoot,
         wrapped.isGitTimeout ? "timeout" : "missing-object",
-        wrapped.gitStderr
+        wrapped.gitStderr,
+        args
       );
     }
     throw wrapped;
@@ -15783,7 +15926,7 @@ function captureWorkingCommitShaOnIndex(repoRoot, indexEnv) {
 function hasUnbornHead(repoRoot) {
   const ref = git(repoRoot, ["symbolic-ref", "--quiet", "HEAD"]);
   const args = ["show-ref", "--verify", "--quiet", ref];
-  const result = spawnSync("git", args, { cwd: repoRoot, ...EXEC_OPTS });
+  const result = spawnSync2("git", args, { cwd: repoRoot, ...EXEC_OPTS });
   if (result.error) throw createGitError(args, result.error);
   return result.status === 1;
 }
@@ -15802,20 +15945,99 @@ function deleteRef(repoRoot, refName) {
 function captureSnapshotSha(repoRoot) {
   return captureWorkingCommitSha(repoRoot);
 }
-function snapshotBlobInventory(repoRoot, treeish) {
-  const blobs = /* @__PURE__ */ new Map();
+var OBJECT_SHA2 = /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/;
+function gitExpectingMissing(repoRoot, args) {
+  return gitBuffer(repoRoot, args, { expectMissingObjects: true }).toString("utf-8").trim();
+}
+function commitTreeSha(repoRoot, commit) {
+  const tree = gitExpectingMissing(repoRoot, [
+    "rev-list",
+    "--no-walk",
+    "--format=%T",
+    commit,
+    "--"
+  ]).split("\n").at(-1);
+  return tree && OBJECT_SHA2.test(tree) ? tree : null;
+}
+function listUnsharedObjects(repoRoot, treeSha, baseTrees) {
+  const out = gitExpectingMissing(repoRoot, [
+    "rev-list",
+    "--objects",
+    treeSha,
+    ...baseTrees.map((base) => `^${base}`),
+    "--"
+  ]);
+  const shas = /* @__PURE__ */ new Set();
+  for (const line of out.split("\n")) {
+    const sha = line.split(" ", 1)[0];
+    if (OBJECT_SHA2.test(sha)) shas.add(sha);
+  }
+  return [...shas];
+}
+function walkBaseTree(repoRoot, tree) {
+  gitExpectingMissing(repoRoot, ["rev-list", "--objects", `^${tree}`, "--"]);
+}
+function blobSizeTotals(repoRoot, shas) {
+  const totals = { bytes: 0, blobs: 0, unreadable: 0 };
+  for (const object of batchCheckObjects(repoRoot, shas)) {
+    if (object.type === "missing") totals.unreadable++;
+    else if (object.type === "blob" && object.size !== null) {
+      totals.bytes += object.size;
+      totals.blobs++;
+    }
+  }
+  return totals;
+}
+var gitVersionCache;
+function gitVersion2(repoRoot) {
+  if (gitVersionCache !== void 0) return gitVersionCache;
+  try {
+    const match = /git version (\d+)\.(\d+)(?:\.(\d+))?/.exec(
+      git(repoRoot, ["--version"])
+    );
+    gitVersionCache = match ? [Number(match[1]), Number(match[2]), Number(match[3] ?? 0)] : null;
+  } catch {
+    gitVersionCache = null;
+  }
+  return gitVersionCache;
+}
+function gitExcludesNegativeTrees(repoRoot) {
+  const version2 = gitVersion2(repoRoot);
+  if (!version2) return true;
+  const [major, minor, patch] = version2;
+  return major > 1 || minor > 8 || minor === 8 && patch >= 5;
+}
+function treeBlobSizes(repoRoot, treeSha) {
+  const sizes = /* @__PURE__ */ new Map();
+  for (const entry of lsTreeEntries(repoRoot, ["-l"], treeSha)) {
+    if (entry.type === "blob" && !sizes.has(entry.sha))
+      sizes.set(
+        entry.sha,
+        /^\d+$/.test(entry.size) ? Number(entry.size) : null
+      );
+  }
+  return sizes;
+}
+function treeBlobShas(repoRoot, treeSha) {
+  const shas = /* @__PURE__ */ new Set();
+  for (const entry of lsTreeEntries(repoRoot, [], treeSha)) {
+    if (entry.type === "blob") shas.add(entry.sha);
+  }
+  return shas;
+}
+function lsTreeEntries(repoRoot, flags, treeSha) {
+  const entries = [];
   for (const entry of gitBuffer(repoRoot, [
     "ls-tree",
     "-r",
-    "-l",
+    ...flags,
     "-z",
-    treeish
+    treeSha
   ]).toString("utf-8").split("\0")) {
-    const [, type, sha, size] = entry.slice(0, entry.indexOf("	")).trim().split(/\s+/);
-    if (type === "blob" && sha && /^\d+$/.test(size ?? ""))
-      blobs.set(sha, Number(size));
+    const [, type, sha, size = ""] = entry.slice(0, entry.indexOf("	")).trim().split(/\s+/);
+    if (type && sha) entries.push({ type, sha, size });
   }
-  return blobs;
+  return entries;
 }
 function formatSize(bytes) {
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -15887,20 +16109,28 @@ function parseDiffTreeRawZ(output) {
 }
 function lookupBlobSizes(repoRoot, shas) {
   const sizes = /* @__PURE__ */ new Map();
-  if (shas.length === 0) return sizes;
+  for (const object of batchCheckObjects(repoRoot, shas)) {
+    if (object.type === "blob" && object.size !== null)
+      sizes.set(object.sha, object.size);
+  }
+  return sizes;
+}
+function batchCheckObjects(repoRoot, shas) {
+  if (shas.length === 0) return [];
   const out = gitBuffer(
     repoRoot,
     ["cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"],
     { input: `${shas.join("\n")}
 ` }
   ).toString("utf-8");
+  const objects = [];
   for (const line of out.split("\n")) {
     const [sha, type, sizeRaw] = line.split(" ");
-    if (type !== "blob") continue;
+    if (!sha || !type) continue;
     const size = Number.parseInt(sizeRaw, 10);
-    if (Number.isFinite(size)) sizes.set(sha, size);
+    objects.push({ sha, type, size: Number.isFinite(size) ? size : null });
   }
-  return sizes;
+  return objects;
 }
 function sortOmittedByPath(files) {
   return [...files].sort(
@@ -16276,7 +16506,8 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
       repoRoot,
       "bundle-create",
       () => gitBuffer(repoRoot, ["bundle", "create", tmpFile, orphanRef], {
-        timeoutMs: resolveGitCommandTimeoutMs(DEFAULT_BUNDLE_TIMEOUT_MS)
+        timeoutMs: resolveGitCommandTimeoutMs(DEFAULT_BUNDLE_TIMEOUT_MS),
+        killProcessGroup: true
       })
     );
     const bundle = fs18.readFileSync(tmpFile);
@@ -16335,7 +16566,7 @@ function gitGzipStream(repoRoot, args, maxGzBytes) {
           GIT_COMMAND_TIMEOUT_MS,
           Date.now() - started
         );
-        probeObjectStore(repoRoot, "timeout", wrapped.gitStderr);
+        probeObjectStore(repoRoot, "timeout", wrapped.gitStderr, args);
         reject(wrapped);
       } else if (overflowed) {
         reject(
@@ -17035,6 +17266,13 @@ function replayBackoffMs(attempts) {
     REPLAY_BACKOFF_MAX_MS
   );
 }
+function bundleBackoffRemainingMs(timeout, now) {
+  if (!timeout) return 0;
+  return Math.max(
+    0,
+    timeout.lastAttemptAt + replayBackoffMs(timeout.attempts) - now
+  );
+}
 function replayEligibility(oldestCapturedAt, replay, now) {
   if (now - oldestCapturedAt < STRANDED_MIN_AGE_MS)
     return { eligible: false, reason: "young" };
@@ -17216,7 +17454,7 @@ function queueDiskBytes(directory) {
   return diskBytes;
 }
 function chargedBytes(record) {
-  return record.retainedBytes ?? record.treeBytes;
+  return record.retainedBytes ?? record.treeBytes ?? 0;
 }
 function pendingBytes(records) {
   const first = records[0];
@@ -17228,42 +17466,109 @@ function pendingBytes(records) {
     0
   );
 }
+function warnMissingBase(repoRoot, base) {
+  appendLog(
+    "warn",
+    `git-traces: capture base is missing for retention accounting; charging unshared content (repo=${repoRoot}, base=${base})`
+  );
+}
 function measureTreeRetention(repoRoot, treeSha, bases, context) {
   const finish = startCaptureStage("tree-inventory", context);
   let status = "failed";
   let details;
   try {
-    const blobs = snapshotBlobInventory(repoRoot, treeSha);
-    const shared = /* @__PURE__ */ new Set();
-    let basesRead = 0;
-    for (const base of new Set(
-      bases.filter((base2) => !!base2)
-    )) {
+    const trees = [
+      ...new Set(bases.trees.filter((base) => !!base))
+    ];
+    if (!trees.includes(treeSha) && bases.headSha) {
       try {
-        const baseBlobs = base === treeSha ? blobs : snapshotBlobInventory(repoRoot, base);
-        for (const sha of baseBlobs.keys()) shared.add(sha);
-        basesRead++;
+        const headTree = commitTreeSha(repoRoot, bases.headSha);
+        if (headTree && !trees.includes(headTree)) trees.push(headTree);
+        if (!headTree) warnMissingBase(repoRoot, bases.headSha);
       } catch (err) {
         if (!isMissingObjectError(err)) throw err;
-        appendLog(
-          "warn",
-          `git-traces: capture base is missing for retention accounting; charging unshared content (repo=${repoRoot}, base=${base})`
-        );
+        warnMissingBase(repoRoot, bases.headSha);
       }
     }
-    let treeBytes = 0;
-    let retainedBytes = 0;
-    for (const [sha, size] of blobs) {
-      treeBytes += size;
-      if (!shared.has(sha)) retainedBytes += size;
+    if (trees.includes(treeSha)) {
+      status = "ok";
+      details = "retainedBytes=0, sameAsBase=yes";
+      return 0;
     }
+    let totals;
+    if (gitExcludesNegativeTrees(repoRoot)) {
+      const { objects, usable } = unsharedObjects(repoRoot, treeSha, trees);
+      totals = { ...blobSizeTotals(repoRoot, objects), used: usable };
+    } else {
+      totals = legacyRetention(repoRoot, treeSha, trees);
+    }
+    const { used } = totals;
     status = "ok";
-    details = `treeBytes=${treeBytes}, treeFiles=${blobs.size}, retainedBytes=${retainedBytes}, bases=${basesRead}`;
-    return { treeBytes, treeFiles: blobs.size, retainedBytes };
+    details = `retainedBytes=${totals.bytes}, retainedBlobs=${totals.blobs}, bases=${used}`;
+    if (totals.unreadable > 0)
+      details += `, unreadableBlobs=${totals.unreadable}`;
+    if (used < trees.length) details += `, droppedBases=${trees.length - used}`;
+    return totals.bytes;
   } finally {
     finish(status, details);
   }
 }
+function legacyRetention(repoRoot, treeSha, bases) {
+  appendLog(
+    "info",
+    `git-traces: git before 1.8.5 ignores negative trees; measuring retention from ls-tree (repo=${repoRoot})`
+  );
+  const shared = /* @__PURE__ */ new Set();
+  let used = 0;
+  for (const base of bases) {
+    try {
+      for (const sha of treeBlobShas(repoRoot, base)) shared.add(sha);
+      used++;
+    } catch (err) {
+      if (!isMissingObjectError(err)) throw err;
+      warnMissingBase(repoRoot, base);
+    }
+  }
+  const totals = { bytes: 0, blobs: 0, unreadable: 0, used };
+  for (const [sha, size] of treeBlobSizes(repoRoot, treeSha)) {
+    if (shared.has(sha)) continue;
+    if (size === null) totals.unreadable++;
+    else {
+      totals.bytes += size;
+      totals.blobs++;
+    }
+  }
+  return totals;
+}
+function unsharedObjects(repoRoot, treeSha, bases) {
+  try {
+    return {
+      objects: listUnsharedObjects(repoRoot, treeSha, bases),
+      usable: bases.length
+    };
+  } catch (err) {
+    if (!isMissingObjectError(err) || bases.length === 0) throw err;
+    const usable = bases.filter((base) => {
+      try {
+        walkBaseTree(repoRoot, base);
+        return true;
+      } catch (baseErr) {
+        if (!isMissingObjectError(baseErr)) throw baseErr;
+        warnMissingBase(repoRoot, base);
+        return false;
+      }
+    });
+    if (usable.length === bases.length)
+      return {
+        objects: listUnsharedObjects(repoRoot, treeSha, bases),
+        usable: bases.length
+      };
+    return {
+      objects: listUnsharedObjects(repoRoot, treeSha, usable),
+      usable: usable.length
+    };
+  }
+}
 async function withCaptureQueueLock(repoRoot, tool, sessionId, work) {
   const lockTool = `${tool}:capture-queue-v1`;
   await acquireLock3(repoRoot, lockTool, sessionId);
@@ -17287,21 +17592,26 @@ function storePendingCapture(params) {
       params.tool,
       params.sessionId
     );
-    const retention = measureTreeRetention(
+    const retainedBytes = measureTreeRetention(
       params.repoRoot,
       input.treeSha,
-      [
-        existing.at(-1)?.treeSha,
-        params.seed.lastSnapshotTreeSha,
-        params.seed.baselineTreeSha,
-        input.headSha
-      ],
+      {
+        trees: [
+          existing.at(-1)?.treeSha,
+          params.seed.lastSnapshotTreeSha,
+          params.seed.baselineTreeSha
+        ],
+        headSha: input.headSha
+      },
       `repo=${params.repoRoot}, tool=${params.tool}, session=${params.sessionId}, recordedAt=${params.recordedAt}`
     );
     const record = {
       ...identity,
       ...input,
-      ...retention,
+      retainedBytes,
+      // 0.8.12 sums treeBytes with no fallback; a missing value would
+      // disable its byte limit for the whole queue.
+      treeBytes: retainedBytes,
       version: 1,
       id: crypto7.randomUUID(),
       sequence: Math.max(Date.now(), (existing.at(-1)?.sequence ?? 0) + 1),
@@ -17310,10 +17620,10 @@ function storePendingCapture(params) {
     const pendingBefore = queueDiskBytes(
       queueDirectory(params.repoRoot, params.tool, params.sessionId)
     ) + existing.reduce((sum, item) => sum + chargedBytes(item), 0);
-    const incomingBytes = retention.retainedBytes + Buffer.byteLength(JSON.stringify(record));
+    const incomingBytes = retainedBytes + Buffer.byteLength(JSON.stringify(record));
     if (existing.length >= MAX_CAPTURES || pendingBefore + incomingBytes > MAX_PENDING_BYTES2) {
       throw new PendingCaptureLimitError(
-        `Pending Git capture limit reached (count=${existing.length}, maxCount=${MAX_CAPTURES}, pendingBytes=${pendingBefore}, incomingBytes=${incomingBytes}, treeBytes=${retention.treeBytes}, 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=${MAX_PENDING_BYTES2}); existing captures retained`
       );
     }
     const directory = captureDirectory(record);
@@ -17355,7 +17665,7 @@ 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)}, treeBytes=${record.treeBytes}, treeFiles=${record.treeFiles}, 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})`
       );
       return record;
     } finally {
@@ -17546,7 +17856,7 @@ async function uploadArtifact(client, contributionId, filename, mimeType, buffer
 }
 
 // package.json
-var version = "0.9.5";
+var version = "0.9.6";
 
 // src/version.ts
 var CLI_VERSION = version;
@@ -19488,6 +19798,53 @@ function freezeEpochBaseline(params) {
     return null;
   }
 }
+function createBundleWithBackoff(pending, params) {
+  const { repoRoot, baselineTreeSha } = params;
+  const previous = pending?.record.bundleTimeout?.input === baselineTreeSha ? pending.record.bundleTimeout : void 0;
+  if (pending && previous) {
+    const retryInMs = bundleBackoffRemainingMs(previous, Date.now());
+    if (retryInMs > 0) {
+      appendLog(
+        "warn",
+        `git-traces: baseline bundle deferred after timeout (repo=${repoRoot}, session=${pending.record.sessionId}, capture=${pending.record.id}, attempts=${previous.attempts}, retryInMs=${retryInMs})`
+      );
+      return null;
+    }
+  }
+  try {
+    const bundle = createBundleFromTree(
+      repoRoot,
+      baselineTreeSha,
+      params.bundleKey,
+      params.label
+    );
+    if (pending?.record.bundleTimeout) {
+      delete pending.record.bundleTimeout;
+      saveBundleBackoff(pending);
+    }
+    return bundle;
+  } catch (err) {
+    if (pending && isGitTimeoutError(err)) {
+      pending.record.bundleTimeout = {
+        input: baselineTreeSha,
+        attempts: (previous?.attempts ?? 0) + 1,
+        lastAttemptAt: Date.now()
+      };
+      saveBundleBackoff(pending);
+    }
+    throw err;
+  }
+}
+function saveBundleBackoff(pending) {
+  try {
+    pending.save();
+  } catch (err) {
+    appendLog(
+      "warn",
+      `git-traces: could not save baseline bundle backoff (capture=${pending.record.id}): ${formatError(err)}`
+    );
+  }
+}
 function buildFrozenEpochBaselineArtifacts(params) {
   const { repoRoot, sessionId, epoch, baselineTreeSha, baselineMetadata } = params;
   const prefix = epochPrefix2(epoch);
@@ -19497,12 +19854,13 @@ function buildFrozenEpochBaselineArtifacts(params) {
       pending,
       `${prefix}-baseline.bundle`,
       baselineTreeSha
-    )) ?? createBundleFromTree(
+    )) ?? createBundleWithBackoff(pending, {
       repoRoot,
       baselineTreeSha,
-      `${sessionId}-${prefix}`,
-      `baseline ${prefix}`
-    );
+      bundleKey: `${sessionId}-${prefix}`,
+      label: `baseline ${prefix}`
+    });
+    if (!bundleBuffer) return null;
     const metadataBuffer = Buffer.from(
       JSON.stringify(baselineMetadata, null, 2)
     );
@@ -21407,6 +21765,10 @@ async function sweepStrandedCaptures(params) {
       tally[state.reason]++;
       continue;
     }
+    if (bundleBackoffRemainingMs(head.bundleTimeout, now) > 0) {
+      tally.backoff++;
+      continue;
+    }
     eligible.push({
       queue,
       oldestCapturedAt,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hillclimb",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "Extract and export AI coding tool logs grouped by repo",
   "license": "MIT",
   "type": "module",