hillclimb 0.4.4 → 0.5.0

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs18 from "fs";
-import path22 from "path";
+import fs19 from "fs";
+import path23 from "path";
 import * as p6 from "@clack/prompts";
 
 // src/commands/init.ts
@@ -617,6 +617,15 @@ var TOOLS = [
         command: HOOK_CMD("upload"),
         timeout: CLAUDE_SESSIONEND_UPLOAD_TIMEOUT_SECONDS
       },
+      // Per-turn transcript capture. SessionEnd is the clean one-shot
+      // upload, but it never fires for sessions that are killed or never
+      // cleanly closed (e.g. long-lived remote sessions), so those
+      // transcripts are lost entirely. Uploading on Stop captures them
+      // turn-by-turn. `--tool=claude` is required: resolveSourceTool()
+      // defaults a bare `upload` on a Stop event to Codex, and the explicit
+      // tool also keys the debug-log agent/git completion correlation to
+      // "claude" (see expectedKinds() in debug-logs.ts).
+      { eventName: "Stop", command: `${HOOK_CMD("upload")} --tool=claude` },
       { eventName: "SessionStart", command: GIT_TRACES_CMD("claude") },
       { eventName: "Stop", command: GIT_TRACES_CMD("claude") },
       { eventName: "SessionEnd", command: GIT_TRACES_CMD("claude") }
@@ -630,6 +639,10 @@ var TOOLS = [
     format: "cursor",
     events: [
       { eventName: "sessionEnd", command: HOOK_CMD("upload") },
+      // Per-turn capture, mirroring Claude. Cursor's stop payload carries a
+      // populated transcript_path (verified on Cursor 3.0.16); --tool=cursor
+      // is required so a bare Stop upload isn't misattributed to Codex.
+      { eventName: "stop", command: `${HOOK_CMD("upload")} --tool=cursor` },
       { eventName: "sessionStart", command: GIT_TRACES_CMD("cursor") },
       { eventName: "stop", command: GIT_TRACES_CMD("cursor") },
       { eventName: "sessionEnd", command: GIT_TRACES_CMD("cursor") }
@@ -854,7 +867,7 @@ function copilotUninstallMatching(settings, eventName, predicate) {
   }
   return true;
 }
-var OPENCODE_PLUGIN_VERSION = 6;
+var OPENCODE_PLUGIN_VERSION = 7;
 var OPENCODE_PLUGIN_MARKER = `// HILLCLIMB_OPENCODE_PLUGIN_VERSION=${OPENCODE_PLUGIN_VERSION}`;
 var OPENCODE_PLUGIN_CONTENT = `${OPENCODE_PLUGIN_MARKER}
 // Auto-installed by \`npx hillclimb\`. Do not edit manually \u2014 re-running
@@ -983,12 +996,29 @@ export const HillclimbPlugin = async ({ directory }) => ({
     }
 
     if (type === "session.idle" && sessionID) {
-      // Per-turn git-traces snapshot only. Transcript upload is deferred to
-      // session.deleted (user-ended) or server.instance.disposed (process exit)
-      // so a single session produces one contribution, not one per turn.
+      // Per-turn snapshot: upload the transcript-so-far AND take a git-traces
+      // snapshot. The CLI keeps this to one contribution per session (reuse),
+      // attaching the latest transcript on each turn, so this is one
+      // contribution per session, not per turn. Keep the buffer \u2014 it's dropped
+      // only on session.deleted / server.instance.disposed.
+      //
+      // Pass transcript_path to BOTH spawns: the debug-log eventId for a stop
+      // event folds in transcript_path, so diverging payloads would orphan the
+      // two completions and double-upload the debug log.
+      const transcriptPath = writeTranscript(sessionID);
+      if (transcriptPath) {
+        spawnHillclimb("upload", {
+          session_id: sessionID,
+          cwd,
+          transcript_path: transcriptPath,
+          hook_event_name: "session.idle",
+          tool: TOOL,
+        });
+      }
       spawnHillclimb("git-traces --tool=opencode", {
         session_id: sessionID,
         cwd,
+        transcript_path: transcriptPath || undefined,
         hook_event_name: "session.idle",
         tool: TOOL,
       });
@@ -2149,15 +2179,32 @@ async function runStatus(args = []) {
 
 // src/commands/upload.ts
 import { spawn as spawn2 } from "child_process";
-import fs10 from "fs";
-import os5 from "os";
-import path13 from "path";
+import fs11 from "fs";
+import os6 from "os";
+import path14 from "path";
 
 // src/debug-logs.ts
 import crypto from "crypto";
 import fs9 from "fs";
 import path11 from "path";
 
+// src/hook-events.ts
+function classifyHookEvent(event) {
+  switch (event) {
+    case "Stop":
+    case "stop":
+    case "session.idle":
+      return "stop";
+    case "SessionEnd":
+    case "sessionEnd":
+    case "session.deleted":
+    case "server.instance.disposed":
+      return "sessionEnd";
+    default:
+      return null;
+  }
+}
+
 // src/middleware/pattern-redact.ts
 import os3 from "os";
 import { Worker } from "worker_threads";
@@ -10916,14 +10963,23 @@ var PlatformUploadOutput = class {
       contributionTitle,
       contributionBody,
       zipFilename,
-      autoSubmit
+      autoSubmit,
+      existingContributionId,
+      onContributionCreated
     } = this.opts;
-    const contribution = await client.createContribution(projectId, {
-      contributionTypeSlug,
-      title: contributionTitle,
-      body: contributionBody
-    });
-    const presigned = await client.createUpload(contribution.id, {
+    let contributionId;
+    if (existingContributionId) {
+      contributionId = existingContributionId;
+    } else {
+      const contribution = await client.createContribution(projectId, {
+        contributionTypeSlug,
+        title: contributionTitle,
+        body: contributionBody
+      });
+      contributionId = contribution.id;
+      if (onContributionCreated) await onContributionCreated(contributionId);
+    }
+    const presigned = await client.createUpload(contributionId, {
       originalFilename: zipFilename,
       mimeType: "application/zip",
       sizeBytes: buffer.byteLength
@@ -10939,11 +10995,11 @@ var PlatformUploadOutput = class {
     );
     appendLog("info", `PUT to presigned URL succeeded for ${zipFilename}`);
     if (autoSubmit) {
-      appendLog("info", `submitting contribution ${contribution.id}`);
-      await client.submitContribution(contribution.id);
-      appendLog("info", `contribution ${contribution.id} submitted`);
+      appendLog("info", `submitting contribution ${contributionId}`);
+      await client.submitContribution(contributionId);
+      appendLog("info", `contribution ${contributionId} submitted`);
     }
-    return contribution.id;
+    return contributionId;
   }
 };
 
@@ -11073,21 +11129,6 @@ function toolLabel(tool) {
   };
   return labels[tool] ?? tool;
 }
-function classifyHookEvent(event) {
-  switch (event) {
-    case "Stop":
-    case "stop":
-    case "session.idle":
-      return "stop";
-    case "SessionEnd":
-    case "sessionEnd":
-    case "session.deleted":
-    case "server.instance.disposed":
-      return "sessionEnd";
-    default:
-      return null;
-  }
-}
 function resolveCwd(payload) {
   return payload.cwd ?? payload.workspace_roots?.[0] ?? null;
 }
@@ -11100,7 +11141,7 @@ function stringOrNull(value) {
 function expectedKinds(tool, eventKind, payload) {
   if (eventKind === "stop") {
     return new Set(
-      tool === "codex" || tool === "copilot-chat" ? ["agent", "git"] : ["git"]
+      tool === "codex" || tool === "copilot-chat" || tool === "claude" || tool === "cursor" || tool === "opencode" ? ["agent", "git"] : ["git"]
     );
   }
   if (tool === "opencode" && !resolveSessionId(payload)) {
@@ -13153,6 +13194,126 @@ var NormalizeMiddleware = class {
   }
 };
 
+// src/upload-state.ts
+import crypto2 from "crypto";
+import fs10 from "fs";
+import os5 from "os";
+import path13 from "path";
+var CURRENT_SCHEMA_VERSION2 = 1;
+var DEFAULT_STATE_DIR = path13.join(
+  os5.homedir(),
+  ".hillclimb",
+  "agent-uploads"
+);
+var LOCK_RETRIES2 = 120;
+var LOCK_RETRY_DELAY_MS2 = 500;
+var DEFAULT_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
+function stateDir2() {
+  return process.env.HILLCLIMB_UPLOAD_STATE_DIR ?? DEFAULT_STATE_DIR;
+}
+function readPositiveEnvMs(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0) return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function stateTtlMs() {
+  return readPositiveEnvMs(
+    "HILLCLIMB_UPLOAD_STATE_TTL_MS",
+    DEFAULT_STATE_TTL_MS
+  );
+}
+function stateFileFor(repoRoot, tool, sessionId) {
+  const hash = crypto2.createHash("sha256").update(`${path13.resolve(repoRoot)}\0${tool}\0${sessionId}`).digest("hex").slice(0, 16);
+  return path13.join(stateDir2(), `${hash}.json`);
+}
+function lockFileFor(repoRoot, tool, sessionId) {
+  return `${stateFileFor(repoRoot, tool, sessionId)}.lock`;
+}
+async function readUploadState(repoRoot, tool, sessionId) {
+  try {
+    const raw = await fs10.promises.readFile(
+      stateFileFor(repoRoot, tool, sessionId),
+      "utf-8"
+    );
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION2) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeUploadState(state) {
+  const file = stateFileFor(state.repoRoot, state.tool, state.sessionId);
+  await fs10.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+  const tmp = `${file}.tmp`;
+  await fs10.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+    mode: 384
+  });
+  await fs10.promises.rename(tmp, file);
+}
+async function deleteUploadState(repoRoot, tool, sessionId) {
+  try {
+    await fs10.promises.unlink(stateFileFor(repoRoot, tool, sessionId));
+  } catch {
+  }
+}
+async function acquireLock2(repoRoot, tool, sessionId, retries = LOCK_RETRIES2, delayMs = LOCK_RETRY_DELAY_MS2) {
+  const lockPath = lockFileFor(repoRoot, tool, sessionId);
+  await fs10.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+  for (let i = 0; i < retries; i++) {
+    try {
+      const fd = await fs10.promises.open(
+        lockPath,
+        fs10.constants.O_CREAT | fs10.constants.O_EXCL | fs10.constants.O_WRONLY
+      );
+      await fd.write(String(process.pid));
+      await fd.close();
+      return;
+    } catch (err) {
+      if (err.code === "EEXIST" && i < retries - 1) {
+        await new Promise((r) => setTimeout(r, delayMs));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`Failed to acquire upload lock after ${retries} retries`);
+}
+async function releaseLock2(repoRoot, tool, sessionId) {
+  try {
+    await fs10.promises.unlink(lockFileFor(repoRoot, tool, sessionId));
+  } catch {
+  }
+}
+async function withUploadLock(repoRoot, tool, sessionId, fn) {
+  await acquireLock2(repoRoot, tool, sessionId);
+  try {
+    return await fn();
+  } finally {
+    await releaseLock2(repoRoot, tool, sessionId);
+  }
+}
+async function sweepStaleUploadStates(ttlMs = stateTtlMs(), now = Date.now()) {
+  let entries;
+  try {
+    entries = await fs10.promises.readdir(stateDir2(), { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const file = path13.join(stateDir2(), entry.name);
+    try {
+      const st = await fs10.promises.stat(file);
+      if (now - st.mtimeMs > ttlMs) {
+        await fs10.promises.unlink(file);
+      }
+    } catch {
+    }
+  }
+}
+
 // src/commands/upload.ts
 async function readStdin() {
   if (process.stdin.isTTY) return "";
@@ -13172,7 +13333,7 @@ function lineHasAssistant(line) {
   return line.includes('"type":"assistant"') || line.includes('"role":"assistant"') || line.includes('"type":"assistant.');
 }
 async function hasAssistantMessage(transcriptPath) {
-  const stream = fs10.createReadStream(transcriptPath, { encoding: "utf-8" });
+  const stream = fs11.createReadStream(transcriptPath, { encoding: "utf-8" });
   let buffer = "";
   try {
     for await (const chunk of stream) {
@@ -13240,8 +13401,8 @@ function resolveCursorTranscriptPath(payload) {
   const workspace = payload.workspace_roots?.[0];
   if (!id || !workspace) return void 0;
   const encoded = workspace.replace(/^\//, "").replace(/\//g, "-");
-  return path13.join(
-    os5.homedir(),
+  return path14.join(
+    os6.homedir(),
     ".cursor",
     "projects",
     encoded,
@@ -13255,9 +13416,10 @@ async function runUploadInner(payload) {
   const transcriptPath = payload.transcript_path ?? resolveCursorTranscriptPath(payload);
   const cwd = payload.cwd ?? payload.workspace_roots?.[0];
   const sourceTool = resolveSourceTool(payload);
+  const eventKind = classifyHookEvent(payload.hook_event_name);
   appendLog(
     "info",
-    `[${sessionId ?? "no-id"}] payload parsed (tool=${sourceTool}, cwd=${cwd ?? "?"})`
+    `[${sessionId ?? "no-id"}] payload parsed (tool=${sourceTool}, cwd=${cwd ?? "?"}, event=${eventKind ?? "?"})`
   );
   if (!sessionId || !transcriptPath || !cwd) {
     appendLog(
@@ -13276,9 +13438,9 @@ async function runUploadInner(payload) {
   }
   const { repoRoot, config } = match;
   await selfHealHook(repoRoot, sourceTool);
-  const transcriptResolved = path13.resolve(transcriptPath);
+  const transcriptResolved = path14.resolve(transcriptPath);
   try {
-    const stat = await fs10.promises.stat(transcriptResolved);
+    const stat = await fs11.promises.stat(transcriptResolved);
     if (!stat.isFile()) {
       appendLog(
         "warn",
@@ -13305,89 +13467,158 @@ async function runUploadInner(payload) {
     transcriptPath: transcriptResolved,
     repoRoot,
     config,
-    sourceTool
+    sourceTool,
+    eventKind
   });
 }
 async function uploadSession(args) {
-  const { sessionId, transcriptPath, repoRoot, config, sourceTool } = args;
-  const now = /* @__PURE__ */ new Date();
-  const sourceFile = {
-    sourceName: sourceTool,
-    absolutePath: transcriptPath,
-    repoPath: repoRoot
-  };
-  const group = {
-    repoPath: repoRoot,
-    label: path13.basename(repoRoot),
-    files: [sourceFile],
-    sourceNames: [sourceTool],
-    lastModified: now
-  };
-  const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path13.join(repoRoot, n));
-  const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
-  const mwChain = [];
-  if (secretResult.values.size > 0) {
-    mwChain.push(new RedactMiddleware(secretResult.values));
-  }
-  mwChain.push(new PatternRedactMiddleware());
-  mwChain.push(new NormalizeMiddleware());
-  const identity = await loadIdentity(config.apiBaseUrl);
-  if (!identity) {
-    appendLog(
-      "error",
-      `Session ${sessionId} upload skipped: no saved login for ${config.apiBaseUrl}. Run \`npx hillclimb login\`.`
+  const { sessionId, transcriptPath, repoRoot, config, sourceTool, eventKind } = args;
+  const isSessionEnd = eventKind === "sessionEnd";
+  await withUploadLock(repoRoot, sourceTool, sessionId, async () => {
+    const prior = await readUploadState(repoRoot, sourceTool, sessionId);
+    let transcriptSize;
+    try {
+      transcriptSize = (await fs11.promises.stat(transcriptPath)).size;
+    } catch {
+    }
+    if (prior?.contributionId && transcriptSize !== void 0 && transcriptSize === prior.lastTranscriptSize) {
+      appendLog(
+        "info",
+        `[${sessionId}] skipping ${sourceTool} ${isSessionEnd ? "SessionEnd" : "Stop"} upload (transcript unchanged at ${transcriptSize} bytes${isSessionEnd ? "; local state cleared" : ""})`
+      );
+      if (isSessionEnd) {
+        await deleteUploadState(repoRoot, sourceTool, sessionId);
+      }
+      return;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const sourceFile = {
+      sourceName: sourceTool,
+      absolutePath: transcriptPath,
+      repoPath: repoRoot
+    };
+    const group = {
+      repoPath: repoRoot,
+      label: path14.basename(repoRoot),
+      files: [sourceFile],
+      sourceNames: [sourceTool],
+      lastModified: now
+    };
+    const envFileNames = await discoverEnvFiles(repoRoot);
+    const envFilePaths = envFileNames.map((n) => path14.join(repoRoot, n));
+    const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
+    const mwChain = [];
+    if (secretResult.values.size > 0) {
+      mwChain.push(new RedactMiddleware(secretResult.values));
+    }
+    mwChain.push(new PatternRedactMiddleware());
+    mwChain.push(new NormalizeMiddleware());
+    const identity = await loadIdentity(config.apiBaseUrl);
+    if (!identity) {
+      appendLog(
+        "error",
+        `Session ${sessionId} upload skipped: no saved login for ${config.apiBaseUrl}. Run \`npx hillclimb login\`.`
+      );
+      return;
+    }
+    const client = new PlatformClient(
+      config.apiBaseUrl,
+      identity.sessionCookie
     );
-    return;
-  }
-  const client = new PlatformClient(config.apiBaseUrl, identity.sessionCookie);
-  const shortId = sessionId.slice(0, 12);
-  const toolLabels = {
-    cursor: "Cursor",
-    codex: "Codex",
-    claude: "Claude",
-    "copilot-chat": "GitHub Copilot Chat",
-    opencode: "opencode"
-  };
-  const toolLabel2 = toolLabels[sourceTool] ?? "Claude";
-  const epochSeconds = formatEpochSeconds2(now);
-  const title = `${toolLabel2} session ${shortId} \u2014 ${epochSeconds}`;
-  const body = `Session ID: ${sessionId}
+    const shortId = sessionId.slice(0, 12);
+    const toolLabels = {
+      cursor: "Cursor",
+      codex: "Codex",
+      claude: "Claude",
+      "copilot-chat": "GitHub Copilot Chat",
+      opencode: "opencode"
+    };
+    const toolLabel2 = toolLabels[sourceTool] ?? "Claude";
+    const epochSeconds = formatEpochSeconds2(now);
+    const seq = (prior?.uploadCount ?? 0) + 1;
+    const title = `${toolLabel2} session ${shortId} \u2014 ${epochSeconds}`;
+    const body = `Session ID: ${sessionId}
 Tool: ${toolLabel2}
 Repo: ${repoRoot}
 Uploaded: ${now.toISOString()}`;
-  const zipFilename = `${sourceTool}-${sanitize2(shortId)}-${epochSeconds}.zip`;
-  const output = new PlatformUploadOutput({
-    client,
-    projectId: config.projectId,
-    contributionTypeSlug: config.contributionTypeSlug,
-    contributionTitle: title,
-    contributionBody: body,
-    zipFilename,
-    autoSubmit: config.autoSubmit
-  });
-  appendLog("info", `[${sessionId}] starting pipeline`);
-  try {
-    const contributionId = await runPipeline(group, mwChain, output, {
-      selectedSources: [sourceTool]
+    const zipFilename = `${sourceTool}-${sanitize2(shortId)}-${epochSeconds}-${String(seq).padStart(3, "0")}.zip`;
+    const alreadySubmitted = prior?.submitted ?? false;
+    const submitThisUpload = config.autoSubmit && !alreadySubmitted;
+    const output = new PlatformUploadOutput({
+      client,
+      projectId: config.projectId,
+      contributionTypeSlug: config.contributionTypeSlug,
+      contributionTitle: title,
+      contributionBody: body,
+      zipFilename,
+      autoSubmit: submitThisUpload,
+      existingContributionId: prior?.contributionId ?? void 0,
+      // Persist the new contribution id before the file PUT so a failed
+      // upload can't make the next Stop create a second contribution.
+      onContributionCreated: (id) => writeUploadState({
+        schemaVersion: CURRENT_SCHEMA_VERSION2,
+        sessionId,
+        tool: sourceTool,
+        repoRoot,
+        projectId: config.projectId,
+        contributionId: id,
+        submitted: alreadySubmitted,
+        uploadCount: prior?.uploadCount ?? 0,
+        firstUploadedAt: prior?.firstUploadedAt ?? now.toISOString(),
+        lastUploadedAt: prior?.lastUploadedAt ?? now.toISOString(),
+        lastTranscriptSize: prior?.lastTranscriptSize
+      })
     });
+    const reuseDesc = prior?.contributionId ? `reusing contribution ${prior.contributionId} (file #${seq})` : prior ? "new contribution (file #1; prior state had no contribution \u2014 earlier create may have failed)" : "new contribution (file #1; first upload for session)";
     appendLog(
       "info",
-      `Uploaded session ${sessionId} to project ${config.projectSlug} (${config.projectId}) as contribution ${contributionId}`
+      `[${sessionId}] ${sourceTool} ${isSessionEnd ? "SessionEnd" : "Stop"} upload \u2192 ${reuseDesc}`
     );
-  } catch (err) {
-    if (err instanceof PlatformError && err.status === 401) {
+    let contributionId;
+    try {
+      contributionId = await runPipeline(group, mwChain, output, {
+        selectedSources: [sourceTool]
+      });
+    } catch (err) {
+      if (err instanceof PlatformError && err.status === 401) {
+        appendLog(
+          "error",
+          `Session ${sessionId} upload failed: authentication expired. Re-run \`npx hillclimb\` in ${repoRoot}.`
+        );
+        return;
+      }
       appendLog(
         "error",
-        `Session ${sessionId} upload failed: authentication expired. Re-run \`npx hillclimb\` in ${repoRoot}.`
+        `Session ${sessionId} upload failed: ${err instanceof Error ? err.message : String(err)}`
       );
       return;
     }
+    const next = {
+      schemaVersion: CURRENT_SCHEMA_VERSION2,
+      sessionId,
+      tool: sourceTool,
+      repoRoot,
+      projectId: config.projectId,
+      contributionId,
+      submitted: alreadySubmitted || submitThisUpload,
+      uploadCount: seq,
+      firstUploadedAt: prior?.firstUploadedAt ?? now.toISOString(),
+      lastUploadedAt: now.toISOString(),
+      lastTranscriptSize: transcriptSize
+    };
+    await writeUploadState(next);
     appendLog(
-      "error",
-      `Session ${sessionId} upload failed: ${err instanceof Error ? err.message : String(err)}`
+      "info",
+      `Uploaded session ${sessionId} to project ${config.projectSlug} (${config.projectId}) as contribution ${contributionId} (seq=${seq})`
     );
-  }
+    if (isSessionEnd) {
+      await deleteUploadState(repoRoot, sourceTool, sessionId);
+      appendLog(
+        "info",
+        `[${sessionId}] session complete \u2014 contribution ${contributionId}, ${seq} file(s); local state cleared`
+      );
+    }
+  });
 }
 var WORKER_ENV_FLAG = "HILLCLIMB_UPLOAD_WORKER";
 var TOOL_ENV_FLAG = "HILLCLIMB_UPLOAD_TOOL";
@@ -13498,22 +13729,26 @@ async function runUploadWorker() {
       tool: resolveSourceTool(payload),
       payload
     });
+    try {
+      await sweepStaleUploadStates();
+    } catch {
+    }
   }
 }
 
 // src/git-traces/index.ts
 import { spawn as spawn3 } from "child_process";
-import crypto3 from "crypto";
+import crypto4 from "crypto";
 
 // src/git-traces/handlers.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import path16 from "path";
+import path17 from "path";
 
 // src/git-traces/git-ops.ts
 import { execFileSync } from "child_process";
-import fs11 from "fs";
-import os6 from "os";
-import path14 from "path";
+import fs12 from "fs";
+import os7 from "os";
+import path15 from "path";
 import { gzipSync } from "zlib";
 var GIT_COMMAND_TIMEOUT_MS = 12e4;
 var EXEC_OPTS = {
@@ -13676,8 +13911,8 @@ function removePathsFromIndex(repoRoot, env, paths) {
 function filterOversizedFilesFromTree(repoRoot, treeSha, options = {}) {
   const oversizedFiles = listOversizedTreeFiles(repoRoot, treeSha, options);
   if (oversizedFiles.length === 0) return treeSha;
-  const tmpIndex = path14.join(
-    os6.tmpdir(),
+  const tmpIndex = path15.join(
+    os7.tmpdir(),
     `hillclimb-filter-${Date.now()}-${process.pid}`
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -13691,7 +13926,7 @@ function filterOversizedFilesFromTree(repoRoot, treeSha, options = {}) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs11.unlinkSync(tmpIndex);
+      fs12.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -13708,7 +13943,7 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
   for (const relPath of list.split("\0")) {
     if (!relPath) continue;
     try {
-      const stat = fs11.lstatSync(path14.join(repoRoot, relPath));
+      const stat = fs12.lstatSync(path15.join(repoRoot, relPath));
       if (stat.size > MAX_SNAPSHOT_FILE_BYTES) {
         recordOmittedSnapshotFile(omittedFiles, {
           path: relPath,
@@ -13723,8 +13958,8 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
     }
   }
   if (kept.length === 0) return null;
-  const tmpIndex = path14.join(
-    os6.tmpdir(),
+  const tmpIndex = path15.join(
+    os7.tmpdir(),
     `hillclimb-untracked-${Date.now()}-${process.pid}`
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -13736,7 +13971,7 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs11.unlinkSync(tmpIndex);
+      fs12.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -13753,8 +13988,8 @@ function buildSnapshotTree(repoRoot, stashSha, options = {}) {
   const untrackedTree = buildUntrackedTree(repoRoot, options.omittedFiles);
   if (!untrackedTree || untrackedTree === EMPTY_TREE_SHA)
     return filteredTrackedTree;
-  const tmpIndex = path14.join(
-    os6.tmpdir(),
+  const tmpIndex = path15.join(
+    os7.tmpdir(),
     `hillclimb-index-${Date.now()}-${process.pid}`
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -13781,7 +14016,7 @@ function buildSnapshotTree(repoRoot, stashSha, options = {}) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs11.unlinkSync(tmpIndex);
+      fs12.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -13795,16 +14030,19 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
   ]);
   const orphanRef = `refs/hillclimb/bundle/${sessionId}`;
   pinRef(repoRoot, orphanRef, orphanCommit);
-  const tmpFile = path14.join(
-    os6.tmpdir(),
-    `hillclimb-bundle-${Date.now()}.bundle`
+  const tmpFile = path15.join(
+    os7.tmpdir(),
+    // Include the pid (like the other temp files in this module) so concurrent
+    // git-traces workers — e.g. two sessions, or a parent + subagent — don't
+    // collide on the same `git bundle create` path and its `.lock`.
+    `hillclimb-bundle-${Date.now()}-${process.pid}.bundle`
   );
   try {
     git(repoRoot, ["bundle", "create", tmpFile, orphanRef]);
-    return fs11.readFileSync(tmpFile);
+    return fs12.readFileSync(tmpFile);
   } finally {
     try {
-      fs11.unlinkSync(tmpFile);
+      fs12.unlinkSync(tmpFile);
     } catch {
     }
     deleteRef(repoRoot, orphanRef);
@@ -13902,7 +14140,7 @@ function buildBaselineMetadata(repoRoot, sessionId, tool, baselineSha, cliVersio
       ...omittedFiles.length > 0 ? { omittedFiles } : {}
     },
     author: { name: authorName, email: authorEmail },
-    hostname: os6.hostname(),
+    hostname: os7.hostname(),
     cliVersion,
     commits
   };
@@ -13991,9 +14229,9 @@ function parseCommitFiles(repoRoot, sha) {
         oldPath
       });
     } else {
-      const path23 = parts[parts.length - 1];
-      indexByPath.set(path23, files.length);
-      files.push({ path: path23, status, additions: 0, deletions: 0 });
+      const path24 = parts[parts.length - 1];
+      indexByPath.set(path24, files.length);
+      files.push({ path: path24, status, additions: 0, deletions: 0 });
     }
   }
   for (const line of numstat.split("\n")) {
@@ -14059,31 +14297,31 @@ function cleanupSessionRefs(repoRoot, sessionId) {
 }
 
 // src/git-traces/session-state.ts
-import crypto2 from "crypto";
-import fs12 from "fs";
-import os7 from "os";
-import path15 from "path";
-var CURRENT_SCHEMA_VERSION2 = 3;
-var DEFAULT_STATE_DIR = path15.join(os7.homedir(), ".hillclimb", "git-traces");
-var LOCK_RETRIES2 = 120;
-var LOCK_RETRY_DELAY_MS2 = 500;
-function stateDir2() {
-  return process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? DEFAULT_STATE_DIR;
+import crypto3 from "crypto";
+import fs13 from "fs";
+import os8 from "os";
+import path16 from "path";
+var CURRENT_SCHEMA_VERSION3 = 3;
+var DEFAULT_STATE_DIR2 = path16.join(os8.homedir(), ".hillclimb", "git-traces");
+var LOCK_RETRIES3 = 120;
+var LOCK_RETRY_DELAY_MS3 = 500;
+function stateDir3() {
+  return process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? DEFAULT_STATE_DIR2;
 }
 function stateFileForRepo(repoRoot, tool, sessionId) {
-  const hash = crypto2.createHash("sha256").update(
-    sessionId ? `${path15.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path15.resolve(repoRoot)}\0${tool}`
+  const hash = crypto3.createHash("sha256").update(
+    sessionId ? `${path16.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path16.resolve(repoRoot)}\0${tool}`
   ).digest("hex").slice(0, 16);
-  return path15.join(stateDir2(), `${hash}.json`);
+  return path16.join(stateDir3(), `${hash}.json`);
 }
 function lockFileForRepo(repoRoot, tool) {
   return `${stateFileForRepo(repoRoot, tool)}.lock`;
 }
 async function readStateFile(file) {
   try {
-    const raw = await fs12.promises.readFile(file, "utf-8");
+    const raw = await fs13.promises.readFile(file, "utf-8");
     const parsed = JSON.parse(raw);
-    if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION2) {
+    if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION3) {
       return null;
     }
     return parsed;
@@ -14094,26 +14332,26 @@ async function readStateFile(file) {
 async function listScopedSessionStates(repoRoot, tool) {
   let entries;
   try {
-    entries = await fs12.promises.readdir(stateDir2(), { withFileTypes: true });
+    entries = await fs13.promises.readdir(stateDir3(), { withFileTypes: true });
   } catch {
     return [];
   }
   const states = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const file = path15.join(stateDir2(), entry.name);
+    const file = path16.join(stateDir3(), entry.name);
     const state = await readStateFile(file);
     if (!state) continue;
     if (typeof state.repoRoot !== "string" || typeof state.sessionId !== "string") {
       continue;
     }
-    if (path15.resolve(state.repoRoot) !== path15.resolve(repoRoot)) continue;
-    if (path15.resolve(file) !== path15.resolve(stateFileForRepo(repoRoot, tool, state.sessionId))) {
+    if (path16.resolve(state.repoRoot) !== path16.resolve(repoRoot)) continue;
+    if (path16.resolve(file) !== path16.resolve(stateFileForRepo(repoRoot, tool, state.sessionId))) {
       continue;
     }
     let mtimeMs = 0;
     try {
-      mtimeMs = (await fs12.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs13.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -14124,26 +14362,26 @@ async function listScopedSessionStates(repoRoot, tool) {
 async function listSessionStatesForSession(tool, sessionId) {
   let entries;
   try {
-    entries = await fs12.promises.readdir(stateDir2(), { withFileTypes: true });
+    entries = await fs13.promises.readdir(stateDir3(), { withFileTypes: true });
   } catch {
     return [];
   }
   const states = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const file = path15.join(stateDir2(), entry.name);
+    const file = path16.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 (path15.resolve(file) !== path15.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
+    if (path16.resolve(file) !== path16.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
       continue;
     }
     let mtimeMs = 0;
     try {
-      mtimeMs = (await fs12.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs13.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -14164,12 +14402,12 @@ async function readSessionState(repoRoot, tool, sessionId) {
 }
 async function writeSessionState(state, tool) {
   const file = stateFileForRepo(state.repoRoot, tool, state.sessionId);
-  await fs12.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+  await fs13.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   const tmp = `${file}.tmp`;
-  await fs12.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+  await fs13.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
     mode: 384
   });
-  await fs12.promises.rename(tmp, file);
+  await fs13.promises.rename(tmp, file);
   const legacyFile = stateFileForRepo(state.repoRoot, tool);
   const legacy = await readStateFile(legacyFile);
   if (legacy?.sessionId === state.sessionId) {
@@ -14178,7 +14416,7 @@ async function writeSessionState(state, tool) {
 }
 async function deleteStateFile(file) {
   try {
-    await fs12.promises.unlink(file);
+    await fs13.promises.unlink(file);
   } catch {
   }
 }
@@ -14194,14 +14432,14 @@ async function deleteSessionState(repoRoot, tool, sessionId) {
   }
   await deleteStateFile(stateFileForRepo(repoRoot, tool));
 }
-async function acquireLock2(repoRoot, tool, retries = LOCK_RETRIES2, delayMs = LOCK_RETRY_DELAY_MS2) {
+async function acquireLock3(repoRoot, tool, retries = LOCK_RETRIES3, delayMs = LOCK_RETRY_DELAY_MS3) {
   const lockPath = lockFileForRepo(repoRoot, tool);
-  await fs12.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+  await fs13.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   for (let i = 0; i < retries; i++) {
     try {
-      const fd = await fs12.promises.open(
+      const fd = await fs13.promises.open(
         lockPath,
-        fs12.constants.O_CREAT | fs12.constants.O_EXCL | fs12.constants.O_WRONLY
+        fs13.constants.O_CREAT | fs13.constants.O_EXCL | fs13.constants.O_WRONLY
       );
       await fd.write(String(process.pid));
       await fd.close();
@@ -14216,9 +14454,9 @@ async function acquireLock2(repoRoot, tool, retries = LOCK_RETRIES2, delayMs = L
   }
   throw new Error(`Failed to acquire lock after ${retries} retries`);
 }
-async function releaseLock2(repoRoot, tool) {
+async function releaseLock3(repoRoot, tool) {
   try {
-    await fs12.promises.unlink(lockFileForRepo(repoRoot, tool));
+    await fs13.promises.unlink(lockFileForRepo(repoRoot, tool));
   } catch {
   }
 }
@@ -14241,12 +14479,12 @@ var TOOL_LABELS = {
 async function loadConfiguredRepos() {
   const file = await loadProjects();
   return Object.entries(file.projects).map(([repoRoot, config]) => ({
-    repoRoot: path16.resolve(repoRoot),
+    repoRoot: path17.resolve(repoRoot),
     config
   })).sort((a, b) => a.repoRoot.localeCompare(b.repoRoot));
 }
 function repoLabel(repoRoot) {
-  return path16.basename(repoRoot) || repoRoot;
+  return path17.basename(repoRoot) || repoRoot;
 }
 function resolveCwd2(payload) {
   return payload.cwd ?? payload.workspace_roots?.[0] ?? null;
@@ -14519,7 +14757,7 @@ async function initializeSession(repoRoot, tool, sessionId) {
   });
   if (!frozen) return null;
   const state = {
-    schemaVersion: CURRENT_SCHEMA_VERSION2,
+    schemaVersion: CURRENT_SCHEMA_VERSION3,
     sessionId,
     contributionId: null,
     baselineSha: frozen.baselineSha,
@@ -14569,7 +14807,7 @@ async function processSessionStartRepo(repo, tool, sessionId) {
     );
     return "skipped";
   }
-  await acquireLock2(repoRoot, tool);
+  await acquireLock3(repoRoot, tool);
   try {
     const staleLegacy = await readSessionState(repoRoot, tool);
     if (staleLegacy && staleLegacy.sessionId !== sessionId) {
@@ -14600,7 +14838,7 @@ async function processSessionStartRepo(repo, tool, sessionId) {
     );
     return "failed";
   } finally {
-    await releaseLock2(repoRoot, tool);
+    await releaseLock3(repoRoot, tool);
   }
 }
 async function handleSessionStart(payload, tool) {
@@ -14700,7 +14938,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
     );
     return "skipped";
   }
-  await acquireLock2(repoRoot, tool);
+  await acquireLock3(repoRoot, tool);
   let state = null;
   try {
     state = await readSessionState(repoRoot, tool, sessionId);
@@ -14901,7 +15139,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
     }
     return "failed";
   } finally {
-    await releaseLock2(repoRoot, tool);
+    await releaseLock3(repoRoot, tool);
   }
 }
 async function handleStop(payload, tool) {
@@ -14918,7 +15156,7 @@ async function handleStop(payload, tool) {
   if (sessionId) {
     const storedStates = await listSessionStatesForSession(tool, sessionId);
     for (const { state } of storedStates) {
-      const repo = repoByRoot.get(path16.resolve(state.repoRoot));
+      const repo = repoByRoot.get(path17.resolve(state.repoRoot));
       if (!repo) {
         missingConfig++;
         appendLog(
@@ -14954,7 +15192,7 @@ async function handleStop(payload, tool) {
   );
 }
 async function cleanupSessionStateForRepo(repoRoot, tool, sessionId) {
-  await acquireLock2(repoRoot, tool);
+  await acquireLock3(repoRoot, tool);
   try {
     const state = await readSessionState(repoRoot, tool, sessionId);
     if (!state) return "no-state";
@@ -14972,7 +15210,7 @@ async function cleanupSessionStateForRepo(repoRoot, tool, sessionId) {
     );
     return "failed";
   } finally {
-    await releaseLock2(repoRoot, tool);
+    await releaseLock3(repoRoot, tool);
   }
 }
 async function handleSessionEnd(payload, tool) {
@@ -14984,7 +15222,7 @@ async function handleSessionEnd(payload, tool) {
   if (sessionId) {
     const states = await listSessionStatesForSession(tool, sessionId);
     for (const { state } of states) {
-      repoRoots.push(path16.resolve(state.repoRoot));
+      repoRoots.push(path17.resolve(state.repoRoot));
     }
   }
   if (repoRoots.length === 0 && cwd) {
@@ -15011,7 +15249,7 @@ var WORKER_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_WORKER";
 var TOOL_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_TOOL";
 var FLOW_ID_ENV = "HILLCLIMB_GIT_TRACES_FLOW";
 function newFlowId() {
-  return crypto3.randomBytes(3).toString("hex");
+  return crypto4.randomBytes(3).toString("hex");
 }
 var KNOWN_TOOLS = /* @__PURE__ */ new Set([
   "claude",
@@ -15297,29 +15535,29 @@ ${stack}` : ""}`
 }
 
 // src/outputs/zip.ts
-import fs14 from "fs";
-import path18 from "path";
+import fs15 from "fs";
+import path19 from "path";
 import archiver2 from "archiver";
 
 // src/outputs/downloads.ts
 import { execSync as execSync2 } from "child_process";
-import fs13 from "fs";
-import os8 from "os";
-import path17 from "path";
+import fs14 from "fs";
+import os9 from "os";
+import path18 from "path";
 function getDownloadsFolder() {
-  const home = os8.homedir();
+  const home = os9.homedir();
   if (process.platform === "linux") {
     try {
       const xdgDir = execSync2("xdg-user-dir DOWNLOAD", {
         encoding: "utf-8",
         timeout: 3e3
       }).trim();
-      if (xdgDir && fs13.existsSync(xdgDir)) return xdgDir;
+      if (xdgDir && fs14.existsSync(xdgDir)) return xdgDir;
     } catch {
     }
   }
-  const downloads = path17.join(home, "Downloads");
-  if (fs13.existsSync(downloads)) return downloads;
+  const downloads = path18.join(home, "Downloads");
+  if (fs14.existsSync(downloads)) return downloads;
   return home;
 }
 
@@ -15328,11 +15566,11 @@ function sanitizeFilename(name) {
   return name.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function getUniqueFilename(dir, base, ext) {
-  let candidate = path18.join(dir, `${base}${ext}`);
-  if (!fs14.existsSync(candidate)) return candidate;
+  let candidate = path19.join(dir, `${base}${ext}`);
+  if (!fs15.existsSync(candidate)) return candidate;
   let i = 1;
-  while (fs14.existsSync(candidate)) {
-    candidate = path18.join(dir, `${base}-${i}${ext}`);
+  while (fs15.existsSync(candidate)) {
+    candidate = path19.join(dir, `${base}-${i}${ext}`);
     i++;
   }
   return candidate;
@@ -15342,13 +15580,13 @@ var ZipOutput = class {
   label = "Save as .zip to Downloads";
   async emit(group, options) {
     const downloadsDir = getDownloadsFolder();
-    const repoName = sanitizeFilename(path18.basename(group.repoPath));
+    const repoName = sanitizeFilename(path19.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 = fs14.createWriteStream(outputPath);
+    const output = fs15.createWriteStream(outputPath);
     const archive = archiver2("zip", { zlib: { level: 6 } });
     const done = new Promise((resolve, reject) => {
       output.on("close", resolve);
@@ -15542,15 +15780,15 @@ async function confirmExport(group, output) {
 }
 
 // src/sources/claude.ts
-import fs15 from "fs";
-import os9 from "os";
-import path19 from "path";
+import fs16 from "fs";
+import os10 from "os";
+import path20 from "path";
 import readline from "readline";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["tool-results"]);
 async function resolveRepoPath(projectDir) {
-  const indexPath = path19.join(projectDir, "sessions-index.json");
+  const indexPath = path20.join(projectDir, "sessions-index.json");
   try {
-    const raw = await fs15.promises.readFile(indexPath, "utf-8");
+    const raw = await fs16.promises.readFile(indexPath, "utf-8");
     const data = JSON.parse(raw);
     if (data.originalPath && typeof data.originalPath === "string") {
       return data.originalPath;
@@ -15558,12 +15796,12 @@ async function resolveRepoPath(projectDir) {
   } catch {
   }
   const cwdCounts = /* @__PURE__ */ new Map();
-  const entries = await fs15.promises.readdir(projectDir, {
+  const entries = await fs16.promises.readdir(projectDir, {
     withFileTypes: true
   });
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-    const cwd = await extractCwdFromJsonl(path19.join(projectDir, entry.name));
+    const cwd = await extractCwdFromJsonl(path20.join(projectDir, entry.name));
     if (cwd) {
       cwdCounts.set(cwd, (cwdCounts.get(cwd) ?? 0) + 1);
     }
@@ -15582,7 +15820,7 @@ async function resolveRepoPath(projectDir) {
   return null;
 }
 async function extractCwdFromJsonl(filePath) {
-  const stream = fs15.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs16.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -15604,12 +15842,12 @@ async function extractCwdFromJsonl(filePath) {
 async function collectFiles(dir, baseDir, sourceName, repoPath, results) {
   let entries;
   try {
-    entries = await fs15.promises.readdir(dir, { withFileTypes: true });
+    entries = await fs16.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path19.join(dir, entry.name);
+    const fullPath = path20.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
       await collectFiles(fullPath, baseDir, sourceName, repoPath, results);
@@ -15631,19 +15869,19 @@ function fallbackDecode(encodedName) {
 var ClaudeSource = class {
   name = "claude";
   async scan() {
-    const baseDir = path19.join(os9.homedir(), ".claude", "projects");
+    const baseDir = path20.join(os10.homedir(), ".claude", "projects");
     try {
-      await fs15.promises.access(baseDir);
+      await fs16.promises.access(baseDir);
     } catch {
       return [];
     }
-    const projectDirs = await fs15.promises.readdir(baseDir, {
+    const projectDirs = await fs16.promises.readdir(baseDir, {
       withFileTypes: true
     });
     const dirEntries = projectDirs.filter((d) => d.isDirectory());
     const resultArrays = await Promise.all(
       dirEntries.map(async (dir) => {
-        const projectPath = path19.join(baseDir, dir.name);
+        const projectPath = path20.join(baseDir, dir.name);
         const repoPath = await resolveRepoPath(projectPath) ?? fallbackDecode(dir.name);
         const files = [];
         await collectFiles(
@@ -15661,12 +15899,12 @@ var ClaudeSource = class {
 };
 
 // src/sources/codex.ts
-import fs16 from "fs";
-import os10 from "os";
-import path20 from "path";
+import fs17 from "fs";
+import os11 from "os";
+import path21 from "path";
 import readline2 from "readline";
 async function parseSessionMeta(filePath) {
-  const stream = fs16.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs17.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -15691,12 +15929,12 @@ async function findJsonlFiles(dir) {
   async function walk(d) {
     let entries;
     try {
-      entries = await fs16.promises.readdir(d, { withFileTypes: true });
+      entries = await fs17.promises.readdir(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path20.join(d, entry.name);
+      const full = path21.join(d, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -15710,11 +15948,11 @@ async function findJsonlFiles(dir) {
 async function loadHistory(historyPath) {
   const map = /* @__PURE__ */ new Map();
   try {
-    await fs16.promises.access(historyPath);
+    await fs17.promises.access(historyPath);
   } catch {
     return map;
   }
-  const stream = fs16.createReadStream(historyPath, { encoding: "utf-8" });
+  const stream = fs17.createReadStream(historyPath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -15741,14 +15979,14 @@ async function loadHistory(historyPath) {
 var CodexSource = class {
   name = "codex";
   async scan() {
-    const codexDir = path20.join(os10.homedir(), ".codex");
-    const sessionsDir = path20.join(codexDir, "sessions");
+    const codexDir = path21.join(os11.homedir(), ".codex");
+    const sessionsDir = path21.join(codexDir, "sessions");
     try {
-      await fs16.promises.access(sessionsDir);
+      await fs17.promises.access(sessionsDir);
     } catch {
       return [];
     }
-    const historyPath = path20.join(codexDir, "history.jsonl");
+    const historyPath = path21.join(codexDir, "history.jsonl");
     const [jsonlFiles, historyMap] = await Promise.all([
       findJsonlFiles(sessionsDir),
       loadHistory(historyPath)
@@ -15771,8 +16009,8 @@ var CodexSource = class {
       });
       const historyLines = historyMap.get(meta.sessionId);
       if (historyLines) {
-        const sessionDir = path20.relative(sessionsDir, path20.dirname(filePath));
-        const historyAbsPath = path20.join(
+        const sessionDir = path21.relative(sessionsDir, path21.dirname(filePath));
+        const historyAbsPath = path21.join(
           sessionsDir,
           sessionDir,
           `history-${meta.sessionId}.jsonl`
@@ -15792,18 +16030,18 @@ var CodexSource = class {
 };
 
 // src/sources/copilotChat.ts
-import fs17 from "fs";
-import os11 from "os";
-import path21 from "path";
+import fs18 from "fs";
+import os12 from "os";
+import path22 from "path";
 import { fileURLToPath } from "url";
 function vsCodeUserDirs() {
-  const home = os11.homedir();
+  const home = os12.homedir();
   const dirs = [
-    path21.join(home, "Library", "Application Support", "Code", "User"),
-    path21.join(home, ".config", "Code", "User")
+    path22.join(home, "Library", "Application Support", "Code", "User"),
+    path22.join(home, ".config", "Code", "User")
   ];
   if (process.env.APPDATA) {
-    dirs.push(path21.join(process.env.APPDATA, "Code", "User"));
+    dirs.push(path22.join(process.env.APPDATA, "Code", "User"));
   }
   return dirs;
 }
@@ -15818,7 +16056,7 @@ function uriToFsPath(uri) {
 async function readWorkspaceFolder(workspaceJsonPath) {
   let raw;
   try {
-    raw = await fs17.promises.readFile(workspaceJsonPath, "utf-8");
+    raw = await fs18.promises.readFile(workspaceJsonPath, "utf-8");
   } catch {
     return null;
   }
@@ -15840,10 +16078,10 @@ var CopilotChatSource = class {
   async scan() {
     const results = [];
     for (const userDir of vsCodeUserDirs()) {
-      const workspaceStorage = path21.join(userDir, "workspaceStorage");
+      const workspaceStorage = path22.join(userDir, "workspaceStorage");
       let hashDirs;
       try {
-        hashDirs = await fs17.promises.readdir(workspaceStorage, {
+        hashDirs = await fs18.promises.readdir(workspaceStorage, {
           withFileTypes: true
         });
       } catch {
@@ -15851,22 +16089,22 @@ var CopilotChatSource = class {
       }
       for (const hash of hashDirs) {
         if (!hash.isDirectory()) continue;
-        const wsRoot = path21.join(workspaceStorage, hash.name);
-        const transcriptsDir = path21.join(
+        const wsRoot = path22.join(workspaceStorage, hash.name);
+        const transcriptsDir = path22.join(
           wsRoot,
           "GitHub.copilot-chat",
           "transcripts"
         );
         let transcriptEntries;
         try {
-          transcriptEntries = await fs17.promises.readdir(transcriptsDir, {
+          transcriptEntries = await fs18.promises.readdir(transcriptsDir, {
             withFileTypes: true
           });
         } catch {
           continue;
         }
         const repoPath = await readWorkspaceFolder(
-          path21.join(wsRoot, "workspace.json")
+          path22.join(wsRoot, "workspace.json")
         );
         if (!repoPath) continue;
         for (const entry of transcriptEntries) {
@@ -15874,7 +16112,7 @@ var CopilotChatSource = class {
           const sessionId = entry.name.slice(0, -".jsonl".length);
           results.push({
             sourceName: this.name,
-            absolutePath: path21.join(transcriptsDir, entry.name),
+            absolutePath: path22.join(transcriptsDir, entry.name),
             repoPath,
             metadata: { sessionId }
           });
@@ -15914,7 +16152,7 @@ function reportRedactionStats(noun, stats) {
 async function filterByTimeRange(group, range) {
   const results = await Promise.all(
     group.files.map(
-      (f) => fs18.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
+      (f) => fs19.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
     )
   );
   const filtered = [];
@@ -15941,10 +16179,10 @@ async function runInteractive() {
   s.start(`Scanning ${source.name} logs...`);
   const allFiles = await source.scan();
   const allGroups = await mergeByRepo(allFiles);
-  const repoRoot = path22.resolve(repo.root);
+  const repoRoot = path23.resolve(repo.root);
   const matching = allGroups.filter((g) => {
-    const resolved = path22.resolve(g.repoPath);
-    return resolved === repoRoot || resolved.startsWith(repoRoot + path22.sep);
+    const resolved = path23.resolve(g.repoPath);
+    return resolved === repoRoot || resolved.startsWith(repoRoot + path23.sep);
   });
   if (matching.length === 0) {
     s.stop(`No ${source.name} logs found for ${repo.name}.`);
@@ -15975,7 +16213,7 @@ async function runInteractive() {
     }
   }
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path22.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path23.join(repoRoot, n));
   const additionalFiles = await promptSecretFiles(envFileNames);
   const secretResult = await collectSecrets(
     repoRoot,

package/package.json

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