hillclimb 0.8.12 → 0.8.13

package/dist/main.js

@@ -14361,7 +14361,7 @@ async function uploadArtifact(client, contributionId, filename, mimeType, buffer
 }
 
 // package.json
-var version = "0.8.12";
+var version = "0.8.13";
 
 // src/version.ts
 var CLI_VERSION = version;
@@ -16120,11 +16120,20 @@ function deleteRef(repoRoot, refName) {
 function captureSnapshotSha(repoRoot) {
   return captureWorkingCommitSha(repoRoot);
 }
-function snapshotTreeBytes(repoRoot, treeSha) {
-  return gitBuffer(repoRoot, ["ls-tree", "-r", "-l", "-z", treeSha]).toString("utf-8").split("\0").reduce((sum, entry) => {
-    const size = entry.slice(0, entry.indexOf("	")).trim().split(/\s+/)[3];
-    return sum + (/^\d+$/.test(size ?? "") ? Number(size) : 0);
-  }, 0);
+function snapshotBlobInventory(repoRoot, treeish) {
+  const blobs = /* @__PURE__ */ new Map();
+  for (const entry of gitBuffer(repoRoot, [
+    "ls-tree",
+    "-r",
+    "-l",
+    "-z",
+    treeish
+  ]).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));
+  }
+  return blobs;
 }
 function formatSize(bytes) {
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -17320,6 +17329,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 PendingCaptureLimitError = class extends Error {
+};
 var activeCapture = new AsyncLocalStorage();
 function currentPendingCapture(repoRoot) {
   const context = activeCapture.getStore();
@@ -17410,10 +17421,7 @@ function listPendingCaptures2(repoRoot, tool, sessionId) {
 function hasPendingCaptures(repoRoot, tool, sessionId) {
   return listPendingCaptures2(repoRoot, tool, sessionId).length > 0;
 }
-function pendingBytes(records) {
-  const first = records[0];
-  if (!first) return 0;
-  const directory = queueDirectory(first.repoRoot, first.tool, first.sessionId);
+function queueDiskBytes(directory) {
   let diskBytes = 0;
   if (fs19.existsSync(directory)) {
     for (const entry of fs19.readdirSync(directory, { withFileTypes: true })) {
@@ -17428,11 +17436,57 @@ function pendingBytes(records) {
       }
     }
   }
-  return diskBytes + records.reduce(
-    (sum, record) => sum + record.treeBytes + (fs19.existsSync(path18.join(captureDirectory(record), "capture.json")) ? 0 : Buffer.byteLength(JSON.stringify(record))),
+  return diskBytes;
+}
+function chargedBytes(record) {
+  return record.retainedBytes ?? record.treeBytes;
+}
+function pendingBytes(records) {
+  const first = records[0];
+  if (!first) return 0;
+  return queueDiskBytes(
+    queueDirectory(first.repoRoot, first.tool, first.sessionId)
+  ) + records.reduce(
+    (sum, record) => sum + chargedBytes(record) + (fs19.existsSync(path18.join(captureDirectory(record), "capture.json")) ? 0 : Buffer.byteLength(JSON.stringify(record))),
     0
   );
 }
+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)
+    )) {
+      try {
+        const baseBlobs = base === treeSha ? blobs : snapshotBlobInventory(repoRoot, base);
+        for (const sha of baseBlobs.keys()) shared.add(sha);
+        basesRead++;
+      } 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})`
+        );
+      }
+    }
+    let treeBytes = 0;
+    let retainedBytes = 0;
+    for (const [sha, size] of blobs) {
+      treeBytes += size;
+      if (!shared.has(sha)) retainedBytes += size;
+    }
+    status = "ok";
+    details = `treeBytes=${treeBytes}, treeFiles=${blobs.size}, retainedBytes=${retainedBytes}, bases=${basesRead}`;
+    return { treeBytes, treeFiles: blobs.size, retainedBytes };
+  } finally {
+    finish(status, details);
+  }
+}
 async function withCaptureQueueLock(repoRoot, tool, sessionId, work) {
   const lockTool = `${tool}:capture-queue-v1`;
   await acquireLock3(repoRoot, lockTool, sessionId);
@@ -17456,17 +17510,33 @@ function storePendingCapture(params) {
       params.tool,
       params.sessionId
     );
+    const retention = measureTreeRetention(
+      params.repoRoot,
+      input.treeSha,
+      [
+        existing.at(-1)?.treeSha,
+        params.seed.lastSnapshotTreeSha,
+        params.seed.baselineTreeSha,
+        input.headSha
+      ],
+      `repo=${params.repoRoot}, tool=${params.tool}, session=${params.sessionId}, recordedAt=${params.recordedAt}`
+    );
     const record = {
       ...identity,
       ...input,
+      ...retention,
       version: 1,
       id: crypto8.randomUUID(),
       sequence: Math.max(Date.now(), (existing.at(-1)?.sequence ?? 0) + 1),
       uploads: {}
     };
-    if (existing.length >= MAX_CAPTURES || pendingBytes([...existing, record]) > MAX_PENDING_BYTES2) {
-      throw new Error(
-        `Pending Git capture limit reached (count=${existing.length}, maxCount=${MAX_CAPTURES}, maxBytes=${MAX_PENDING_BYTES2}); existing captures retained`
+    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));
+    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`
       );
     }
     const directory = captureDirectory(record);
@@ -17508,7 +17578,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)})`
+        `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})`
       );
       return record;
     } finally {
@@ -17694,6 +17764,8 @@ var TOOL_LABELS = {
   "copilot-chat": "GitHub Copilot Chat",
   opencode: "opencode"
 };
+var PendingQueueConflictError = class extends Error {
+};
 async function loadConfiguredRepos() {
   const file = await loadProjects();
   return Object.entries(file.projects).map(([repoRoot, config]) => ({
@@ -19456,7 +19528,7 @@ async function queueStopCapture(repo, tool, sessionId, recordedAt, sessionEnd =
         const queued = listPendingCaptures2(repo.repoRoot, tool, sessionId);
         const state = candidates.scoped?.state ?? queued[0]?.seed;
         if (candidates.legacy && queued.length > 0)
-          throw new Error(
+          throw new PendingQueueConflictError(
             "Legacy state appeared while Git captures were pending; preserve the queue for session reconciliation"
           );
         if (!state || candidates.legacy || !state.baselineTreeSha || !state.baselineMetadata)
@@ -19518,7 +19590,6 @@ async function queueStopCapture(repo, tool, sessionId, recordedAt, sessionEnd =
                   headSha,
                   captureStartedAt,
                   capturedAt,
-                  treeBytes: snapshotTreeBytes(repo.repoRoot, treeSha),
                   metadata,
                   omittedFiles,
                   scan: scanOut[0]
@@ -19545,13 +19616,30 @@ async function queueStopCapture(repo, tool, sessionId, recordedAt, sessionEnd =
       }
     );
   } catch (err) {
+    if (err instanceof PendingCaptureLimitError) {
+      appendLog(
+        "error",
+        `git-traces: Stop capture rejected for repo ${repo.repoRoot} (session=${sessionId}, sessionEnd=${sessionEnd}): ${formatError(err)}`
+      );
+      return "rejected";
+    }
     appendLog(
       "error",
       `git-traces: Stop failed for repo ${repo.repoRoot} during immutable capture (session=${sessionId}): ${formatError(err)}`
     );
-    return "failed";
+    return err instanceof PendingQueueConflictError ? "conflict" : "failed";
   }
 }
+async function drainRetainedCaptures(repo, tool, sessionId, capture, lineageCheck) {
+  if (capture === "conflict" || !sessionId || !hasPendingCaptures(repo.repoRoot, tool, sessionId))
+    return void 0;
+  const outcome = await drainStopCaptures(repo, tool, sessionId, lineageCheck);
+  appendLog(
+    outcome === "failed" ? "warn" : "info",
+    `git-traces: retained captures drained after ${capture} capture (repo=${repo.repoRoot}, session=${sessionId}, outcome=${outcome})`
+  );
+  return outcome;
+}
 async function drainStopCaptures(repo, tool, sessionId, lineageCheck) {
   const drainTool = `${tool}:capture-drain-v1`;
   try {
@@ -19566,7 +19654,7 @@ async function drainStopCaptures(repo, tool, sessionId, lineageCheck) {
       "info",
       `git-traces: capture pending behind active drainer (repo=${repo.repoRoot}, session=${sessionId})`
     );
-    return "skipped";
+    return "pending";
   }
   let locked = true;
   let uploaded = false;
@@ -19750,10 +19838,12 @@ async function handleStop(payload, tool) {
   let uploaded = 0;
   let unchanged = 0;
   let skipped = missingConfig;
+  let pending = 0;
   let noState = missingStateRoots.filter(
     (root) => !targetsByRoot.has(root)
   ).length;
   let failed = initializationFailed;
+  let rejected = 0;
   const captures = /* @__PURE__ */ new Map();
   for (const repo of targetList) {
     captures.set(
@@ -19762,23 +19852,33 @@ async function handleStop(payload, tool) {
     );
   }
   for (const repo of targetList) {
-    const capture = captures.get(repo.repoRoot);
-    const outcome = capture === "failed" ? "failed" : capture === "queued" && sessionId ? await drainStopCaptures(repo, tool, sessionId, lineageCheck) : await processStopRepo(
-      repo,
-      tool,
-      sessionId,
-      recordedAt,
-      lineageCheck
-    );
+    const capture = captures.get(repo.repoRoot) ?? "failed";
+    let outcome;
+    if (capture === "queued" && sessionId) {
+      outcome = await drainStopCaptures(repo, tool, sessionId, lineageCheck);
+    } else if (capture === "queued" || capture === "direct") {
+      outcome = await processStopRepo(
+        repo,
+        tool,
+        sessionId,
+        recordedAt,
+        lineageCheck
+      );
+    } else {
+      outcome = "failed";
+      if (capture === "rejected") rejected++;
+      await drainRetainedCaptures(repo, tool, sessionId, capture, lineageCheck);
+    }
     if (outcome === "uploaded") uploaded++;
     else if (outcome === "unchanged") unchanged++;
     else if (outcome === "skipped") skipped++;
+    else if (outcome === "pending") pending++;
     else if (outcome === "no-state") noState++;
     else failed++;
   }
   appendLog(
     "info",
-    `git-traces: Stop summary (session=${sessionId ?? "<none>"}, tool=${tool}, triggerRepo=${project.repoRoot}, configured=${repos.length}, frozenStates=${frozenStates}, uploaded=${uploaded}, unchanged=${unchanged}, skipped=${skipped}, noState=${noState}, failed=${failed})`
+    `git-traces: Stop summary (session=${sessionId ?? "<none>"}, tool=${tool}, triggerRepo=${project.repoRoot}, configured=${repos.length}, frozenStates=${frozenStates}, uploaded=${uploaded}, unchanged=${unchanged}, skipped=${skipped}, noState=${noState}, failed=${failed}, rejected=${rejected}, pending=${pending})`
   );
 }
 async function cleanupSessionStateForRepo(repoRoot, tool, sessionId) {
@@ -19871,7 +19971,9 @@ async function handleSessionEnd(payload, tool) {
   let uploaded = 0;
   let unchanged = 0;
   let skipped = 0;
+  let pending = 0;
   let failed = 0;
+  let rejected = 0;
   const finalCaptures = /* @__PURE__ */ new Map();
   for (const repoRoot of repoRoots) {
     const repo = repoByRoot.get(path19.resolve(repoRoot)) ?? (project && path19.resolve(project.repoRoot) === path19.resolve(repoRoot) ? { repoRoot: project.repoRoot, config: project.config } : null);
@@ -19891,8 +19993,24 @@ async function handleSessionEnd(payload, tool) {
       );
       continue;
     }
-    const finalCapture = finalCaptures.get(repoRoot);
-    const finalOutcome = finalCapture === "failed" ? "failed" : finalCapture === "queued" && sessionId ? await drainStopCaptures(repo, tool, sessionId, lineageCheck) : await processStopRepo(
+    const finalCapture = finalCaptures.get(repoRoot) ?? "failed";
+    if (finalCapture !== "queued" && finalCapture !== "direct") {
+      failed++;
+      if (finalCapture === "rejected") rejected++;
+      appendLog(
+        "warn",
+        `git-traces: preserving SessionEnd state for repo ${repoRoot} after ${finalCapture} final capture`
+      );
+      await drainRetainedCaptures(
+        repo,
+        tool,
+        sessionId,
+        finalCapture,
+        lineageCheck
+      );
+      continue;
+    }
+    const finalOutcome = finalCapture === "queued" && sessionId ? await drainStopCaptures(repo, tool, sessionId, lineageCheck) : await processStopRepo(
       repo,
       tool,
       sessionId,
@@ -19902,7 +20020,14 @@ async function handleSessionEnd(payload, tool) {
     );
     if (finalOutcome === "uploaded") uploaded++;
     else if (finalOutcome === "unchanged") unchanged++;
-    else if (finalOutcome === "skipped") {
+    else if (finalOutcome === "pending") {
+      pending++;
+      appendLog(
+        "info",
+        `git-traces: final capture queued behind active drainer for repo ${repoRoot}`
+      );
+      continue;
+    } else if (finalOutcome === "skipped") {
       skipped++;
       appendLog(
         "warn",
@@ -19924,7 +20049,7 @@ async function handleSessionEnd(payload, tool) {
   }
   appendLog(
     "info",
-    `git-traces: SessionEnd summary (session=${sessionId ?? "<none>"}, tool=${tool}, triggerRepo=${triggerRepo}, states=${repoRoots.size}, uploaded=${uploaded}, unchanged=${unchanged}, skipped=${skipped}, cleaned=${cleaned}, noState=${noState}, failed=${failed})`
+    `git-traces: SessionEnd summary (session=${sessionId ?? "<none>"}, tool=${tool}, triggerRepo=${triggerRepo}, states=${repoRoots.size}, uploaded=${uploaded}, unchanged=${unchanged}, skipped=${skipped}, cleaned=${cleaned}, noState=${noState}, failed=${failed}, rejected=${rejected}, pending=${pending})`
   );
 }
 

package/package.json

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