hillclimb 0.8.0 → 0.8.1

package/dist/cli.js

@@ -12040,10 +12040,8 @@ function expectedKinds(tool, eventKind2, payload) {
   }
   return /* @__PURE__ */ new Set(["agent", "git"]);
 }
-async function transcriptFingerprint(payload) {
-  const transcriptPath = stringOrNull(payload.transcript_path);
-  if (!transcriptPath) return {};
-  const resolved = path13.resolve(transcriptPath);
+var TRANSCRIPT_STAT_ENV = "HILLCLIMB_DEBUG_LOG_TRANSCRIPT_STAT";
+async function statTranscriptFingerprint(resolved) {
   try {
     const stat = await fs12.promises.stat(resolved);
     return {
@@ -12055,6 +12053,44 @@ async function transcriptFingerprint(payload) {
     return { transcriptPath: resolved };
   }
 }
+function pinnedTranscriptFingerprint(resolved) {
+  const raw = process.env[TRANSCRIPT_STAT_ENV];
+  if (!raw) return null;
+  try {
+    const pinned = JSON.parse(raw);
+    return pinned.transcriptPath === resolved ? pinned : null;
+  } catch {
+    return null;
+  }
+}
+async function transcriptFingerprint(payload) {
+  const transcriptPath = stringOrNull(payload.transcript_path);
+  if (!transcriptPath) return {};
+  const resolved = path13.resolve(transcriptPath);
+  return pinnedTranscriptFingerprint(resolved) ?? await statTranscriptFingerprint(resolved);
+}
+async function captureDebugLogParentEnv(rawPayload) {
+  let payload;
+  try {
+    payload = JSON.parse(rawPayload);
+  } catch {
+    return {};
+  }
+  if (typeof payload !== "object" || payload === null) return {};
+  const transcriptPath = stringOrNull(payload.transcript_path);
+  if (classifyHookEvent(payload.hook_event_name) !== "stop" || stringOrNull(payload.turn_id) !== null || !transcriptPath) {
+    return {};
+  }
+  return {
+    [TRANSCRIPT_STAT_ENV]: JSON.stringify(
+      await statTranscriptFingerprint(path13.resolve(transcriptPath))
+    )
+  };
+}
+async function applyDebugLogParentEnv(env, rawPayload) {
+  delete env[TRANSCRIPT_STAT_ENV];
+  Object.assign(env, await captureDebugLogParentEnv(rawPayload));
+}
 async function eventContext(tool, payload) {
   const eventKind2 = classifyHookEvent(payload.hook_event_name);
   if (!eventKind2) return null;
@@ -12085,6 +12121,10 @@ async function eventContext(tool, payload) {
     // Only stop events without stable turn IDs need the transcript to
     // disambiguate. When a turn_id exists, including mutable transcript
     // mtime/size can split agent+git completions for the same logical event.
+    // Workers prefer the stat their hook parent pinned via
+    // TRANSCRIPT_STAT_ENV, so completion-time skew between the agent and git
+    // workers no longer splits the eventId; the residual window is the
+    // parents' dispatch skew (see captureDebugLogParentEnv).
     ...eventKind2 === "stop" && !turnId ? await transcriptFingerprint(payload) : {}
   };
   const eventId = crypto2.createHash("sha256").update(JSON.stringify(fingerprint)).digest("hex").slice(0, 32);
@@ -12373,7 +12413,7 @@ async function uploadDebugLog(ctx, state, sessionState, onContributionCreated) {
       `Session ID: ${ctx.sessionId}`,
       `Tool: ${label}`,
       `Repo: ${ctx.repoRoot}`,
-      "Log snapshots: complete Hillclimb daily log snapshots captured at hook events"
+      "Log snapshots: machine-wide Hillclimb daily log snapshots captured at hook events; may include entries from other sessions on this machine"
     ].join("\n")
   } : {
     contributionTitle: `${label} debug log ${shortSession} - ${epochSeconds}`,
@@ -12788,6 +12828,21 @@ async function writeCursorState(repoRoot, tool, sessionId, cursor) {
   });
   await fs14.promises.rename(tmp, file);
 }
+async function setUploadSessionEndedAt(repoRoot, tool, sessionId, sessionEndedAt) {
+  const state = await readUploadState(repoRoot, tool, sessionId);
+  if (!state) return false;
+  await writeUploadState({ ...state, sessionEndedAt });
+  const now = /* @__PURE__ */ new Date();
+  try {
+    await fs14.promises.utimes(
+      cursorFileFor(repoRoot, tool, sessionId),
+      now,
+      now
+    );
+  } catch {
+  }
+  return true;
+}
 async function acquireLock2(repoRoot, tool, sessionId, retries = lockRetries(), delayMs = lockRetryDelayMs()) {
   const lockPath = lockFileFor(repoRoot, tool, sessionId);
   await fs14.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
@@ -13240,10 +13295,22 @@ async function uploadSession(args) {
         } else {
           appendLog(
             "info",
-            `[${sessionId}] skipping ${sourceTool} ${eventLabel} upload (no new complete transcript lines past offset ${cursor.rawByteOffset}${isSessionEnd ? "; local state cleared" : ""})`
+            `[${sessionId}] skipping ${sourceTool} ${eventLabel} upload (no new complete transcript lines past offset ${cursor.rawByteOffset}${isSessionEnd ? "; session state retained for late hooks" : ""})`
           );
           if (isSessionEnd) {
-            await deleteUploadState(repoRoot, sourceTool, sessionId);
+            await setUploadSessionEndedAt(
+              repoRoot,
+              sourceTool,
+              sessionId,
+              new Date(recordedAt).toISOString()
+            );
+          } else if (prior?.sessionEndedAt) {
+            await setUploadSessionEndedAt(
+              repoRoot,
+              sourceTool,
+              sessionId,
+              void 0
+            );
           }
           return true;
         }
@@ -13313,14 +13380,20 @@ async function uploadSession(args) {
         uploadCount: prior.uploadCount + 1,
         codexLineage,
         codexLineageChecked,
-        codexLineageStamped: codexLineage
+        codexLineageStamped: codexLineage,
+        sessionEndedAt: void 0
       });
       appendLog(
         "info",
         `[${sessionId}] refreshed ${sourceTool} lineage meta for unchanged epoch=${epoch2}`
       );
       if (isSessionEnd) {
-        await deleteUploadState(repoRoot, sourceTool, sessionId);
+        await setUploadSessionEndedAt(
+          repoRoot,
+          sourceTool,
+          sessionId,
+          new Date(recordedAt).toISOString()
+        );
       }
       return true;
     }
@@ -13491,10 +13564,15 @@ async function uploadSession(args) {
         `Uploaded session ${sessionId} patch epoch=${epoch2} turn=${turn} to contribution ${contributionId2} (offset ${baseCursor.rawByteOffset} \u2192 ${nextCursor.rawByteOffset})`
       );
       if (isSessionEnd) {
-        await deleteUploadState(repoRoot, sourceTool, sessionId);
+        await setUploadSessionEndedAt(
+          repoRoot,
+          sourceTool,
+          sessionId,
+          new Date(recordedAt).toISOString()
+        );
         appendLog(
           "info",
-          `[${sessionId}] session complete \u2014 contribution ${contributionId2}, epoch ${epoch2}, ${turn} patch(es); local state cleared`
+          `[${sessionId}] session complete \u2014 contribution ${contributionId2}, epoch ${epoch2}, ${turn} patch(es); session state retained for late hooks`
         );
       }
       return true;
@@ -13522,8 +13600,21 @@ async function uploadSession(args) {
         "info",
         `[${sessionId}] skipping ${sourceTool} ${eventLabel} upload (no complete transcript line yet)`
       );
-      if (isSessionEnd)
-        await deleteUploadState(repoRoot, sourceTool, sessionId);
+      if (isSessionEnd) {
+        await setUploadSessionEndedAt(
+          repoRoot,
+          sourceTool,
+          sessionId,
+          new Date(recordedAt).toISOString()
+        );
+      } else if (prior?.sessionEndedAt) {
+        await setUploadSessionEndedAt(
+          repoRoot,
+          sourceTool,
+          sessionId,
+          void 0
+        );
+      }
       return true;
     }
     const epoch = (prior?.epoch ?? restored?.epoch ?? 0) + 1;
@@ -13670,10 +13761,15 @@ Uploaded: ${now.toISOString()}`;
       `Uploaded session ${sessionId} snapshot epoch=${epoch} to project ${config.projectSlug} (${config.projectId}) as contribution ${contributionId}`
     );
     if (isSessionEnd) {
-      await deleteUploadState(repoRoot, sourceTool, sessionId);
+      await setUploadSessionEndedAt(
+        repoRoot,
+        sourceTool,
+        sessionId,
+        new Date(recordedAt).toISOString()
+      );
       appendLog(
         "info",
-        `[${sessionId}] session complete \u2014 contribution ${contributionId}, epoch ${epoch} snapshot; local state cleared`
+        `[${sessionId}] session complete \u2014 contribution ${contributionId}, epoch ${epoch} snapshot; session state retained for late hooks`
       );
     }
     return true;
@@ -13727,6 +13823,7 @@ async function runUpload() {
     [FLOW_ID_ENV]: flowId
   };
   if (toolArg) workerEnv[TOOL_ENV_FLAG] = toolArg;
+  await applyDebugLogParentEnv(workerEnv, raw);
   try {
     const child = spawn2(process.execPath, [entrypoint, "upload"], {
       detached: true,
@@ -14580,6 +14677,18 @@ function cleanupSessionRefs(repoRoot, sessionId) {
     }
   }
 }
+function countScopedTurnTreeRefs(repoRoot, sessionId, epochPrefix3) {
+  const base = `refs/hillclimb/scoped/${sessionId}/turns/`;
+  try {
+    return git(repoRoot, [
+      "for-each-ref",
+      "--format=%(refname)",
+      epochPrefix3 ? `${base}${epochPrefix3}/` : base
+    ]).split("\n").filter((ref) => ref.endsWith("/tree")).length;
+  } catch {
+    return 0;
+  }
+}
 
 // src/git-traces/session-state.ts
 import crypto6 from "crypto";
@@ -14731,6 +14840,27 @@ async function writeStateFile(file, state) {
   });
   await fs17.promises.rename(tmp, file);
 }
+async function touchSessionState(repoRoot, tool, sessionId) {
+  const now = /* @__PURE__ */ new Date();
+  try {
+    await fs17.promises.utimes(
+      stateFileForRepo(repoRoot, tool, sessionId),
+      now,
+      now
+    );
+  } catch {
+  }
+}
+async function statSessionStateMtime(repoRoot, tool, sessionId) {
+  try {
+    const stat = await fs17.promises.stat(
+      stateFileForRepo(repoRoot, tool, sessionId)
+    );
+    return stat.mtimeMs;
+  } catch {
+    return null;
+  }
+}
 async function deleteStateFile(file) {
   try {
     await fs17.promises.unlink(file);
@@ -15317,7 +15447,7 @@ async function cleanupStaleScopedSessionStates(repoRoot, tool, currentSessionId,
   for (const { state, mtimeMs } of states) {
     if (state.sessionId === currentSessionId) continue;
     const startedAtMs = Date.parse(state.startedAt);
-    const ageBaseMs = Number.isNaN(startedAtMs) ? mtimeMs : startedAtMs;
+    const ageBaseMs = Number.isNaN(startedAtMs) ? mtimeMs : Math.max(startedAtMs, mtimeMs);
     if (nowMs - ageBaseMs <= ttlMs) continue;
     if (await readLegacySessionState(repoRoot, tool, state.sessionId)) {
       appendLog(
@@ -15336,9 +15466,32 @@ async function cleanupStaleScopedSessionStates(repoRoot, tool, currentSessionId,
       continue;
     }
     try {
+      const lockedMtimeMs = await statSessionStateMtime(
+        repoRoot,
+        tool,
+        state.sessionId
+      );
+      if (lockedMtimeMs === null) continue;
+      const lockedBaseMs = Number.isNaN(startedAtMs) ? lockedMtimeMs : Math.max(startedAtMs, lockedMtimeMs);
+      if (nowMs - lockedBaseMs <= ttlMs) {
+        appendLog(
+          "info",
+          `git-traces: leaving session ${state.sessionId} (state refreshed before reap)`
+        );
+        continue;
+      }
+      const pinnedTurnTrees = countScopedTurnTreeRefs(
+        repoRoot,
+        state.sessionId,
+        epochPrefix2(state.epoch)
+      );
+      const totalPinnedTurnTrees = countScopedTurnTreeRefs(
+        repoRoot,
+        state.sessionId
+      );
       appendLog(
         "info",
-        `git-traces: cleaning up stale scoped session ${state.sessionId}`
+        `git-traces: cleaning up stale scoped session ${state.sessionId} (epoch=${state.epoch}, uploadedTurns=${state.turnCount}, pinnedTurnTrees=${pinnedTurnTrees}, unuploadedPinnedTurns=${Math.max(0, pinnedTurnTrees - state.turnCount)}, totalPinnedTurnTrees=${totalPinnedTurnTrees}, contribution=${state.contributionId ?? "<none>"})`
       );
       cleanupSessionRefs(repoRoot, state.sessionId);
       await deleteSessionState2(repoRoot, tool, state.sessionId);
@@ -15384,6 +15537,7 @@ async function prepareSessionStartRepo(repo, tool, sessionId, lineage) {
     const scoped = (await readSessionStateCandidates(repoRoot, tool, sessionId)).scoped?.state;
     if (scoped) {
       pinScopedStateRefs(repoRoot, scoped);
+      await touchSessionState(repoRoot, tool, sessionId);
       return "initialized";
     }
     const state = await initializeSession(
@@ -15935,7 +16089,11 @@ async function processStopRepo(repo, tool, sessionId, recordedAt, lineageCheck,
       { limits }
     );
     if (!patchBuffer) {
-      if (omissionsChanged) await persistState(state);
+      if (omissionsChanged) {
+        await persistState(state);
+      } else {
+        await touchSessionState(state.repoRoot, tool, sessionId);
+      }
       appendLog(
         "info",
         `git-traces: turn produced identical snapshot tree, skipping upload (repo=${repoRoot}, project=${config.projectId})`
@@ -16439,6 +16597,13 @@ async function runGitTraces() {
     appendLog("error", "git-traces: process.argv[1] is empty");
     return;
   }
+  const workerEnv = {
+    ...process.env,
+    [WORKER_ENV_FLAG2]: "1",
+    [TOOL_ENV_FLAG2]: tool,
+    [FLOW_ID_ENV2]: flowId
+  };
+  await applyDebugLogParentEnv(workerEnv, raw);
   try {
     const child = spawn3(
       process.execPath,
@@ -16446,12 +16611,7 @@ async function runGitTraces() {
       {
         detached: true,
         stdio: ["pipe", "ignore", "ignore"],
-        env: {
-          ...process.env,
-          [WORKER_ENV_FLAG2]: "1",
-          [TOOL_ENV_FLAG2]: tool,
-          [FLOW_ID_ENV2]: flowId
-        }
+        env: workerEnv
       }
     );
     child.on("error", (err) => {

package/package.json

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