hillclimb 0.8.3 → 0.8.5

package/dist/main.js

@@ -2349,7 +2349,11 @@ var VOLATILE_KEYS = /* @__PURE__ */ new Set([
   "wall_time_ms"
 ]);
 function sessionsDir() {
-  return process.env.HILLCLIMB_CODEX_SESSIONS_DIR ?? path9.join(os3.homedir(), ".codex", "sessions");
+  if (process.env.HILLCLIMB_CODEX_SESSIONS_DIR) {
+    return process.env.HILLCLIMB_CODEX_SESSIONS_DIR;
+  }
+  const codexHome = process.env.CODEX_HOME || path9.join(os3.homedir(), ".codex");
+  return path9.join(codexHome, "sessions");
 }
 function asRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -2519,6 +2523,10 @@ async function findCodexRolloutPath(sessionId) {
   }
   return void 0;
 }
+async function isCodexInternalThread(payload, sessionId) {
+  if (!sessionId || payload.transcript_path) return false;
+  return await findCodexRolloutPath(sessionId) === void 0;
+}
 function commonPrefixLength(a, b) {
   const limit = Math.min(a.length, b.length);
   let count = 0;
@@ -11762,14 +11770,20 @@ function getSourceBaseDir(sourceName) {
   }
 }
 function archivePathFor(file) {
+  return path11.posix.join(file.sourceName, path11.basename(file.absolutePath));
+}
+function legacyArchivePathFor(file) {
   const baseDir = getSourceBaseDir(file.sourceName);
   const relativePath = file.absolutePath.startsWith(baseDir) ? path11.relative(baseDir, file.absolutePath) : path11.basename(file.absolutePath);
   return path11.join(file.sourceName, relativePath);
 }
 function addGroupToArchive(archive, group, selectedSources) {
+  const used = /* @__PURE__ */ new Set();
   for (const file of group.files) {
     if (!selectedSources.has(file.sourceName)) continue;
-    const archivePath = archivePathFor(file);
+    let archivePath = archivePathFor(file);
+    if (used.has(archivePath)) archivePath = legacyArchivePathFor(file);
+    used.add(archivePath);
     if (file.content) {
       archive.append(file.content, { name: archivePath });
     } else {
@@ -13065,7 +13079,7 @@ async function runUploadInner(payload) {
       "warn",
       `Skipping upload: missing required hook fields (session_id=${!!sessionId}, transcript_path=${!!payload.transcript_path}, cwd=${!!cwd})`
     );
-    return false;
+    return "skipped";
   }
   const match = await findProjectForCwd(cwd);
   if (!match) {
@@ -13073,13 +13087,13 @@ async function runUploadInner(payload) {
       "warn",
       `Skipping session ${sessionId}: no hillclimb config for cwd ${cwd}. Run \`npx hillclimb\` in the repo.`
     );
-    return false;
+    return "skipped";
   }
   const { repoRoot, config } = match;
   const sourceTool = await resolveSourceTool(payload, repoRoot);
   if (!sourceTool) {
     payload.tool = "unknown";
-    return false;
+    return "skipped";
   }
   payload.tool = sourceTool;
   appendLog(
@@ -13093,11 +13107,18 @@ async function runUploadInner(payload) {
     sessionId
   );
   if (!transcriptPath) {
+    if (sourceTool === "codex") {
+      appendLog(
+        "info",
+        `Skipping session ${sessionId}: Codex internal thread (no transcript_path and no rollout under ~/.codex/sessions); not a user session`
+      );
+      return "internal-thread";
+    }
     appendLog(
       "warn",
       `Skipping upload: missing required hook fields (session_id=true, transcript_path=false, cwd=true)`
     );
-    return false;
+    return "skipped";
   }
   const transcriptResolved = path15.resolve(transcriptPath);
   try {
@@ -13107,23 +13128,32 @@ async function runUploadInner(payload) {
         "warn",
         `Skipping session ${sessionId}: transcript_path is not a file: ${transcriptResolved}`
       );
-      return false;
+      return "skipped";
     }
   } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    const missing = err?.code === "ENOENT";
+    if (missing && eventKind2 === "sessionEnd") {
+      appendLog(
+        "info",
+        `Skipping session ${sessionId}: session ended without any turns; transcript was never written (${transcriptResolved})`
+      );
+      return "skipped";
+    }
     appendLog(
       "warn",
-      `Skipping session ${sessionId}: transcript_path not readable (${transcriptResolved}): ${err instanceof Error ? err.message : String(err)}`
+      `Skipping session ${sessionId}: transcript_path not readable (${transcriptResolved}): ${detail}`
     );
-    return false;
+    return "skipped";
   }
   if (!await hasAssistantMessage(transcriptResolved)) {
     appendLog(
       "info",
       `Skipping session ${sessionId}: transcript contains no assistant messages (nothing to upload).`
     );
-    return false;
+    return "skipped";
   }
-  return await uploadSession({
+  const uploaded = await uploadSession({
     sessionId,
     transcriptPath: transcriptResolved,
     repoRoot,
@@ -13132,6 +13162,7 @@ async function runUploadInner(payload) {
     eventKind: eventKind2,
     recordedAt
   });
+  return uploaded ? "uploaded" : "skipped";
 }
 var AGENT_MAX_UPLOAD_BYTES = 1024 * 1024 * 1024;
 var CLI_VERSION = "0.8.0";
@@ -13351,6 +13382,10 @@ async function uploadSession(args) {
       sourceName: sourceTool,
       absolutePath: transcriptPath
     });
+    const legacyTranscriptArchivePath = legacyArchivePathFor({
+      sourceName: sourceTool,
+      absolutePath: transcriptPath
+    });
     const alreadySubmitted = prior?.submitted ?? false;
     const submitThisUpload = config.autoSubmit && !alreadySubmitted;
     if (mode === "meta-refresh" && prior?.contributionId && prior.epochMeta && cursor) {
@@ -13428,7 +13463,7 @@ async function uploadSession(args) {
           epochMeta2 = {
             transitionKind: "legacy-adopted",
             baseline: "legacy-latest-zip",
-            transcriptArchivePath,
+            transcriptArchivePath: legacyTranscriptArchivePath,
             rawByteOffset: baseCursor.rawByteOffset,
             rawPrefixSha256: baseCursor.rawPrefixSha256
           };
@@ -13444,7 +13479,7 @@ async function uploadSession(args) {
               epoch: epoch2,
               transitionKind: "legacy-adopted",
               baseline: "legacy-latest-zip",
-              transcriptArchivePath,
+              transcriptArchivePath: legacyTranscriptArchivePath,
               cursor: baseCursor,
               recordedAt,
               lineage: codexLineage
@@ -13885,16 +13920,16 @@ async function runUploadWorker() {
   const toolOverride = process.env[TOOL_ENV_FLAG];
   if (toolOverride) payload.tool = toolOverride;
   appendLog("info", `worker: payload summary: ${summarizePayload(payload)}`);
-  let completed = false;
+  let outcome = "skipped";
   try {
-    completed = await runUploadInner(payload);
+    outcome = await runUploadInner(payload);
   } catch (err) {
     appendLog(
       "error",
       `worker: unexpected error: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
     );
   } finally {
-    if (completed) {
+    if (outcome !== "internal-thread") {
       await recordDebugLogCompletion({
         kind: "agent",
         tool: fallbackSourceTool(payload),
@@ -13910,7 +13945,7 @@ async function runUploadWorker() {
 }
 
 // src/git-traces/index.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import crypto7 from "crypto";
 
 // src/git-traces/handlers.ts
@@ -13918,11 +13953,11 @@ import { execFileSync as execFileSync3 } from "child_process";
 import path18 from "path";
 
 // src/git-traces/git-ops.ts
-import { execFileSync as execFileSync2, spawnSync } from "child_process";
+import { execFileSync as execFileSync2, spawn as spawn3, spawnSync } from "child_process";
 import fs16 from "fs";
 import os8 from "os";
 import path16 from "path";
-import { gzipSync as gzipSync2 } from "zlib";
+import { createGzip } from "zlib";
 var GIT_COMMAND_TIMEOUT_MS = 12e4;
 var EXEC_OPTS = {
   timeout: GIT_COMMAND_TIMEOUT_MS,
@@ -14150,7 +14185,7 @@ function createGitError(args, err) {
   const failure = err;
   const command = formatGitCommand(args);
   const isTimeout = failure.code === "ETIMEDOUT";
-  const message = isTimeout ? `${command} timed out after ${GIT_COMMAND_TIMEOUT_MS}ms` : formatGitFailure(command, failure, err);
+  const message = isTimeout ? `${command} timed out after ${GIT_COMMAND_TIMEOUT_MS}ms` : failure.code === "ENOBUFS" ? `${command} output exceeded the ${formatSize(failure.maxBufferBytes ?? EXEC_OPTS.maxBuffer)} limit` : formatGitFailure(command, failure, err);
   const wrapped = new Error(message);
   wrapped.isGitTimeout = isTimeout;
   return wrapped;
@@ -14442,7 +14477,111 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
     deleteRef(repoRoot, orphanRef);
   }
 }
-function createTreeDiffPatchGz(repoRoot, fromTreeSha, toTreeSha, options = {}) {
+var MAX_PATCH_GZ_BYTES = 500 * 1024 * 1024;
+function gitGzipStream(repoRoot, args, maxGzBytes) {
+  return new Promise((resolve, reject) => {
+    const child = spawn3("git", args, {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const gzip = createGzip();
+    const gzChunks = [];
+    const stderrChunks = [];
+    let gzBytes = 0;
+    let rawBytes = 0;
+    let stderrBytes = 0;
+    let settled = false;
+    let timedOut = false;
+    let overflowed = false;
+    let streamError = null;
+    let exitCode = null;
+    let exitSignal = null;
+    let childClosed = false;
+    let gzipDone = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, GIT_COMMAND_TIMEOUT_MS);
+    const finish = () => {
+      if (settled || !childClosed || !gzipDone) return;
+      settled = true;
+      clearTimeout(timer);
+      if (timedOut) {
+        reject(createGitError(args, { code: "ETIMEDOUT" }));
+      } else if (overflowed) {
+        reject(
+          createGitError(args, { code: "ENOBUFS", maxBufferBytes: maxGzBytes })
+        );
+      } else if (streamError) {
+        reject(createGitError(args, streamError));
+      } else if (exitCode !== 0 || exitSignal) {
+        reject(
+          createGitError(args, {
+            status: exitCode,
+            signal: exitSignal,
+            stderr: Buffer.concat(stderrChunks)
+          })
+        );
+      } else {
+        resolve({ gz: Buffer.concat(gzChunks), rawBytes });
+      }
+    };
+    child.stdout.on("data", (chunk) => {
+      rawBytes += chunk.length;
+    });
+    child.stdout.on("error", (err) => {
+      streamError ??= err;
+      gzipDone = true;
+      finish();
+    });
+    child.stdout.pipe(gzip);
+    gzip.on("data", (chunk) => {
+      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();
+        }
+        return;
+      }
+      gzChunks.push(chunk);
+    });
+    gzip.on("end", () => {
+      gzipDone = true;
+      finish();
+    });
+    gzip.on("error", (err) => {
+      if (!overflowed) streamError ??= err;
+      gzipDone = true;
+      finish();
+    });
+    child.stderr.on("data", (chunk) => {
+      if (stderrBytes < 16 * 1024) {
+        stderrChunks.push(chunk);
+        stderrBytes += chunk.length;
+      }
+    });
+    child.on("error", (err) => {
+      streamError ??= err;
+      childClosed = true;
+      gzipDone = true;
+      finish();
+    });
+    child.on("close", (code, signal) => {
+      exitCode = code;
+      exitSignal = signal;
+      childClosed = true;
+      finish();
+    });
+  });
+}
+async function createTreeDiffPatchGz(repoRoot, fromTreeSha, toTreeSha, options = {}) {
   if (fromTreeSha === toTreeSha) return null;
   const filteredFromTreeSha = filterOmittedFilesFromTree(
     repoRoot,
@@ -14453,14 +14592,13 @@ function createTreeDiffPatchGz(repoRoot, fromTreeSha, toTreeSha, options = {}) {
     limits: options.limits
   });
   if (filteredFromTreeSha === filteredToTreeSha) return null;
-  const diff = gitBuffer(repoRoot, [
-    "diff",
-    "--binary",
-    filteredFromTreeSha,
-    filteredToTreeSha
-  ]);
-  if (diff.length === 0) return null;
-  return Buffer.from(gzipSync2(diff));
+  const { gz, rawBytes } = await gitGzipStream(
+    repoRoot,
+    ["diff", "--binary", filteredFromTreeSha, filteredToTreeSha],
+    options.maxPatchGzBytes ?? MAX_PATCH_GZ_BYTES
+  );
+  if (rawBytes === 0) return null;
+  return gz;
 }
 function detectTransitionKind(repoRoot, prevHeadSha, nextHeadSha) {
   if (!prevHeadSha) return "initial";
@@ -14961,6 +15099,7 @@ var CLI_VERSION2 = "0.8.0";
 var GIT_TRACES_SLUG = "git-traces";
 var MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
 var STALE_SCOPED_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
+var REBASELINE_AFTER_DIFF_FAILURES = 2;
 function formatEpochSeconds3(date) {
   return String(Math.floor(date.getTime() / 1e3));
 }
@@ -15844,6 +15983,107 @@ async function refreshLineageBaseline(params) {
     return false;
   }
 }
+async function recoverFromWedgedDiff(params) {
+  const {
+    repo,
+    state,
+    tool,
+    persistState,
+    limits,
+    currentSha,
+    currentTreeSha,
+    turnOmittedFiles
+  } = params;
+  const { repoRoot, config } = repo;
+  if (state.contributionId === null || !state.baselineUploaded) {
+    const prefix = epochPrefix2(state.epoch);
+    pinRef(
+      repoRoot,
+      `refs/hillclimb/baseline/${state.sessionId}/${prefix}/tracked`,
+      currentSha
+    );
+    pinRef(
+      repoRoot,
+      `refs/hillclimb/scoped/${state.sessionId}/baseline/${prefix}/tracked`,
+      currentSha
+    );
+    pinFrozenBaselineTree(
+      repoRoot,
+      state.sessionId,
+      state.epoch,
+      currentTreeSha
+    );
+    const metadata = buildBaselineMetadata(
+      repoRoot,
+      state.sessionId,
+      tool,
+      currentSha,
+      CLI_VERSION2,
+      state.epoch,
+      null,
+      "initial",
+      state.startedAt,
+      turnOmittedFiles,
+      state.codexLineage
+    );
+    Object.assign(state, {
+      baselineSha: currentSha,
+      baselineTreeSha: currentTreeSha,
+      baselineMetadata: metadata,
+      lastSnapshotSha: currentSha,
+      lastSnapshotTreeSha: currentTreeSha,
+      headSha: captureHeadSha(repoRoot),
+      turnCount: 0,
+      omittedKeys: omissionKeys(turnOmittedFiles)
+    });
+    delete state.diffFailureCount;
+    await persistState(state);
+    appendLog(
+      "warn",
+      `git-traces: wedge-recovery replaced the unuploaded ${prefix} baseline at the current state; the wedged interval is not recoverable (repo=${repoRoot}, project=${config.projectId}, session=${state.sessionId})`
+    );
+    return "skipped";
+  }
+  const client = await loadRepoClient(repo);
+  if (!client) return "skipped";
+  const nextEpoch = await reserveEpoch(state, persistState);
+  appendLog(
+    "warn",
+    `git-traces: wedge-recovery abandoning the incremental chain after ${state.diffFailureCount} consecutive diff failures (repo=${repoRoot}, project=${config.projectId}, contribution=${state.contributionId}, abandonedEpoch=${state.epoch}, lastUploadedTurn=${state.turnCount}, openingEpoch=${nextEpoch})`
+  );
+  const artifacts = await openEpoch({
+    repoRoot,
+    client,
+    contributionId: state.contributionId,
+    sessionId: state.sessionId,
+    tool,
+    epoch: nextEpoch,
+    prevHeadSha: state.headSha || null,
+    transitionKind: "initial",
+    startedAt: state.startedAt,
+    limits,
+    lineage: state.codexLineage
+  });
+  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,
+    codexLineageStamped: state.codexLineage
+  });
+  delete state.diffFailureCount;
+  await persistState(state);
+  appendLog(
+    "info",
+    `git-traces: wedge-recovery baseline uploaded (repo=${repoRoot}, project=${config.projectId}, contribution=${state.contributionId}, epoch=${nextEpoch}, baseline=${artifacts.baselineSha.slice(0, 8)})`
+  );
+  return "uploaded";
+}
 async function registerInitialContribution(params) {
   const { repo, state, tool, persistState, client, artifacts } = params;
   const contributionId = await createGitTracesContribution({
@@ -16076,6 +16316,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt, lineageCheck,
         omittedKeys: artifacts.omittedKeys,
         codexLineageStamped: state.codexLineage
       };
+      delete next.diffFailureCount;
       await persistState(next);
       appendLog(
         "info",
@@ -16090,19 +16331,55 @@ async function processStopRepo(repo, tool, sessionId, recordedAt, lineageCheck,
       log: false,
       limits
     });
+    const previousOmittedKeys = state.omittedKeys;
     const omissionsChanged = reportNewlyOmittedFiles(
       state,
       turnOmittedFiles,
       repoRoot
     );
-    const patchBuffer = createTreeDiffPatchGz(
-      repoRoot,
-      lastSnapshotTreeSha,
-      currentTreeSha,
-      { limits }
-    );
+    const attemptWedgeRecovery = async () => {
+      const outcome = await recoverFromWedgedDiff({
+        repo,
+        state: cleanupState,
+        tool,
+        persistState,
+        limits,
+        currentSha,
+        currentTreeSha,
+        turnOmittedFiles
+      });
+      return outcome === "uploaded" ? await finishSuccessfulStop("uploaded") : outcome;
+    };
+    if ((state.diffFailureCount ?? 0) >= REBASELINE_AFTER_DIFF_FAILURES) {
+      appendLog(
+        "warn",
+        `git-traces: skipping turn diff after ${state.diffFailureCount} consecutive failures; retrying wedge recovery (repo=${repoRoot}, project=${config.projectId})`
+      );
+      return await attemptWedgeRecovery();
+    }
+    let patchBuffer;
+    try {
+      patchBuffer = await createTreeDiffPatchGz(
+        repoRoot,
+        lastSnapshotTreeSha,
+        currentTreeSha,
+        { limits }
+      );
+    } catch (err) {
+      const failures = (state.diffFailureCount ?? 0) + 1;
+      state.diffFailureCount = failures;
+      await persistState({ ...state, omittedKeys: previousOmittedKeys });
+      appendLog(
+        "error",
+        `git-traces: turn diff failed (repo=${repoRoot}, project=${config.projectId}, consecutiveFailures=${failures}): ${formatError(err)}`
+      );
+      if (failures < REBASELINE_AFTER_DIFF_FAILURES) return "failed";
+      return await attemptWedgeRecovery();
+    }
+    const diffFailuresCleared = state.diffFailureCount !== void 0;
+    delete state.diffFailureCount;
     if (!patchBuffer) {
-      if (omissionsChanged) {
+      if (omissionsChanged || diffFailuresCleared) {
         await persistState(state);
       } else {
         await touchSessionState(state.repoRoot, tool, sessionId);
@@ -16618,7 +16895,7 @@ async function runGitTraces() {
   };
   await applyDebugLogParentEnv(workerEnv, raw);
   try {
-    const child = spawn3(
+    const child = spawn4(
       process.execPath,
       [entrypoint, "git-traces", `--tool=${tool}`],
       {
@@ -16693,6 +16970,13 @@ async function runGitTracesWorker() {
     );
     return;
   }
+  if (tool === "codex" && await isCodexInternalThread(payload, resolveHookSessionId(payload))) {
+    appendLog(
+      "info",
+      `git-traces: skipping Codex internal thread ${resolveHookSessionId(payload)} on ${event} (no transcript_path and no rollout on disk; not a user session)`
+    );
+    return;
+  }
   try {
     await selfHealHook2(payload, tool);
     switch (eventKind2) {

package/package.json

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