hillclimb 0.8.9 → 0.8.11

package/dist/main.js

@@ -12,8 +12,8 @@ import {
 } from "./chunk-IFGDO3FI.js";
 
 // src/main.ts
-import fs22 from "fs";
-import path22 from "path";
+import fs23 from "fs";
+import path23 from "path";
 import * as p6 from "@clack/prompts";
 
 // src/commands/init.ts
@@ -121,17 +121,24 @@ async function putToPresignedUrl(url, headers, body, options) {
   const contentLength = body.kind === "buffer" ? body.buffer.byteLength : body.sizeBytes;
   const start = Date.now();
   return new Promise((resolve, reject) => {
+    let inputStream;
+    let progressTimer;
+    let phase = "connecting";
     let settled = false;
     const settleResolve = (result) => {
       if (settled) return;
       settled = true;
       clearTimeout(deadlineTimer);
+      clearInterval(progressTimer);
+      inputStream?.destroy();
       resolve(result);
     };
     const settleReject = (err) => {
       if (settled) return;
       settled = true;
       clearTimeout(deadlineTimer);
+      clearInterval(progressTimer);
+      inputStream?.destroy();
       reject(err);
     };
     const req = transport.request(
@@ -145,6 +152,7 @@ async function putToPresignedUrl(url, headers, body, options) {
         headers: { ...headers, "content-length": String(contentLength) }
       },
       (res) => {
+        phase = "receiving-response";
         const chunks = [];
         let buffered = 0;
         res.on("data", (chunk) => {
@@ -174,6 +182,28 @@ async function putToPresignedUrl(url, headers, body, options) {
       req.destroy(err);
     }, deadlineMs);
     deadlineTimer.unref();
+    req.on("socket", (socket) => {
+      const connected = () => {
+        if (phase === "connecting") phase = "sending";
+      };
+      if (parsed.protocol === "https:") socket.once("secureConnect", connected);
+      else if (!socket.connecting) connected();
+      else socket.once("connect", connected);
+    });
+    req.on("finish", () => {
+      if (phase !== "receiving-response") phase = "awaiting-response";
+    });
+    if (options?.onProgress) {
+      progressTimer = setInterval(() => {
+        options.onProgress?.({
+          elapsedMs: Date.now() - start,
+          phase,
+          socketBytesWritten: req.socket?.bytesWritten ?? 0,
+          totalBodyBytes: contentLength
+        });
+      }, options.progressIntervalMs ?? 3e4);
+      progressTimer.unref();
+    }
     req.setTimeout(socketIdleTimeoutMs, () => {
       const err = new Error(
         `PUT to presigned URL timed out: socket idle for ${socketIdleTimeoutMs}ms (elapsed ${Date.now() - start}ms)`
@@ -185,12 +215,12 @@ async function putToPresignedUrl(url, headers, body, options) {
     if (body.kind === "buffer") {
       req.end(body.buffer);
     } else {
-      const stream = fs2.createReadStream(body.path);
-      stream.on("error", (err) => {
+      inputStream = fs2.createReadStream(body.path);
+      inputStream.on("error", (err) => {
         settleReject(err);
         req.destroy(err);
       });
-      stream.pipe(req);
+      inputStream.pipe(req);
     }
   });
 }
@@ -524,22 +554,25 @@ var PlatformClient = class {
       input
     );
   }
-  async uploadToPresignedUrl(presignedUrl, headers, body) {
-    await this.putToPresignedUrlLogged(presignedUrl, headers, {
-      kind: "buffer",
-      buffer: body
-    });
+  async uploadToPresignedUrl(presignedUrl, headers, body, refresh) {
+    await this.putToPresignedUrlLogged(
+      presignedUrl,
+      headers,
+      { kind: "buffer", buffer: body },
+      refresh
+    );
   }
   // Same logging and error shape as uploadToPresignedUrl, but streams the
   // file from disk so large snapshots never have to fit in memory.
-  async uploadFileToPresignedUrl(presignedUrl, headers, filePath, sizeBytes) {
-    await this.putToPresignedUrlLogged(presignedUrl, headers, {
-      kind: "file",
-      path: filePath,
-      sizeBytes
-    });
+  async uploadFileToPresignedUrl(presignedUrl, headers, filePath, sizeBytes, refresh) {
+    await this.putToPresignedUrlLogged(
+      presignedUrl,
+      headers,
+      { kind: "file", path: filePath, sizeBytes },
+      refresh
+    );
   }
-  async putToPresignedUrlLogged(presignedUrl, headers, body) {
+  async putToPresignedUrlLogged(presignedUrl, headers, body, refresh) {
     const host = (() => {
       try {
         return new URL(presignedUrl).host;
@@ -549,11 +582,17 @@ var PlatformClient = class {
     })();
     const sizeBytes = body.kind === "buffer" ? body.buffer.byteLength : body.sizeBytes;
     let hadNetworkError = false;
+    let refreshed = false;
     for (let attempt = 1; ; attempt++) {
       const start = Date.now();
       let res;
       try {
-        res = await putToPresignedUrl(presignedUrl, headers, body);
+        res = await putToPresignedUrl(presignedUrl, headers, body, {
+          onProgress: (progress) => appendLog(
+            "info",
+            `[PUT ${host}] progress (attempt=${attempt}, phase=${progress.phase}, elapsedMs=${progress.elapsedMs}, socketBytesWritten=${progress.socketBytesWritten}, totalBodyBytes=${progress.totalBodyBytes})`
+          )
+        });
       } catch (err) {
         hadNetworkError = true;
         const delayMs2 = putRetryDelayMs({
@@ -589,6 +628,33 @@ var PlatformClient = class {
         );
         return;
       }
+      const code = /<Code>\s*([A-Za-z][A-Za-z0-9]*)\s*<\/Code>/.exec(
+        res.bodyText
+      )?.[1];
+      if ((res.status === 400 || res.status === 403) && code === "ExpiredToken" && refresh && attempt < MAX_ATTEMPTS && !refreshed) {
+        refreshed = true;
+        appendLog(
+          "warn",
+          `[PUT ${host}] ${res.status} ${elapsedMs}ms (code=ExpiredToken); refreshing AWS upload URL once for the existing object`
+        );
+        const renewed = await this.request(
+          "POST",
+          `/api/v1/contributions/${encodeURIComponent(refresh.contributionId)}/uploads/${encodeURIComponent(refresh.uploadId)}/refresh`
+        );
+        const previousUrl = new URL(presignedUrl);
+        const renewedUrl = new URL(renewed.presignedUrl);
+        const conditionalHeader = Object.entries(renewed.headers).find(
+          ([name]) => name.toLowerCase() === "if-none-match"
+        )?.[1];
+        if (renewed.upload.id !== refresh.uploadId || renewed.upload.declaredSizeBytes !== sizeBytes || renewedUrl.origin !== previousUrl.origin || renewedUrl.pathname !== previousUrl.pathname || conditionalHeader !== "*") {
+          throw new PlatformError(
+            "Refreshed upload must preserve the upload ID, object, and write-once precondition"
+          );
+        }
+        presignedUrl = renewed.presignedUrl;
+        headers = renewed.headers;
+        continue;
+      }
       const delayMs = putRetryDelayMs({ attempt, status: res.status });
       if (delayMs !== null) {
         appendLog(
@@ -598,11 +664,15 @@ var PlatformClient = class {
         await sleep(delayMs);
         continue;
       }
-      appendLog("warn", `[PUT ${host}] ${res.status} ${elapsedMs}ms`);
-      const detail = res.bodyText;
+      const detail = code ? `(code=${code})` : res.bodyText;
+      appendLog(
+        "warn",
+        `[PUT ${host}] ${res.status} ${elapsedMs}ms${code ? ` (code=${code})` : ""}`
+      );
       throw new PlatformError(
         `PUT to presigned URL failed: HTTP ${res.status}${detail ? ` ${detail}` : ""}`,
-        res.status
+        res.status,
+        code
       );
     }
   }
@@ -2345,9 +2415,41 @@ async function runStatus(args = []) {
 // src/commands/upload.ts
 import { spawn as spawn2 } from "child_process";
 import crypto5 from "crypto";
-import fs13 from "fs";
-import os6 from "os";
-import path13 from "path";
+import fs14 from "fs";
+import os7 from "os";
+import path14 from "path";
+
+// src/agent-timing.ts
+async function measureAgentStage(stage, action) {
+  appendLog("info", `agent-upload: timing (stage=${stage}, status=started)`);
+  const started = performance.now();
+  let status = "failed";
+  try {
+    const result = await action();
+    status = "ok";
+    return result;
+  } finally {
+    appendLog(
+      "info",
+      `agent-upload: timing (stage=${stage}, status=${status}, elapsedMs=${Math.round(performance.now() - started)})`
+    );
+  }
+}
+function measureAgentSyncStage(stage, action) {
+  appendLog("info", `agent-upload: timing (stage=${stage}, status=started)`);
+  const started = performance.now();
+  let status = "failed";
+  try {
+    const result = action();
+    status = "ok";
+    return result;
+  } finally {
+    appendLog(
+      "info",
+      `agent-upload: timing (stage=${stage}, status=${status}, elapsedMs=${Math.round(performance.now() - started)})`
+    );
+  }
+}
 
 // src/codex-lineage.ts
 import crypto from "crypto";
@@ -2788,8 +2890,8 @@ async function detectCodexLineage(childPath) {
 
 // src/debug-logs.ts
 import crypto2 from "crypto";
-import fs10 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path12 from "path";
 
 // src/hook-events.ts
 function classifyHookEvent(event) {
@@ -2877,7 +2979,7 @@ async function reapLockIfStaleImpl(lockPath, opts, beforeOwnerRecheck) {
   if (age < (opts.graceMs ?? DEFAULT_LOCK_GRACE_MS)) return false;
   const ownerPid = await readLockPid(lockPath);
   const alive = opts.isProcessAlive ?? isProcessAlive;
-  const shouldReap = ownerPid === null ? age > opts.maxAgeMs : !alive(ownerPid) || age > opts.maxAgeMs;
+  const shouldReap = ownerPid === null ? age > opts.maxAgeMs : !alive(ownerPid) || !opts.preserveLiveOwner && age > opts.maxAgeMs;
   if (!shouldReap) return false;
   try {
     await beforeOwnerRecheck?.(lockPath);
@@ -12099,7 +12201,11 @@ async function collectSecrets(repoRoot, envFiles, additionalFiles) {
 }
 
 // src/outputs/platform.ts
-import { PassThrough } from "stream";
+import fs9 from "fs";
+import os5 from "os";
+import path10 from "path";
+import { Transform } from "stream";
+import { pipeline } from "stream/promises";
 import archiver from "archiver";
 
 // src/outputs/archive.ts
@@ -12153,21 +12259,34 @@ var UploadTooLargeError = class extends Error {
     this.name = "UploadTooLargeError";
   }
 };
-async function buildZipBuffer(group, selectedSources) {
+async function buildZipFile(group, selectedSources, filePath, zipFilename, maxUploadBytes) {
   const archive = archiver("zip", { zlib: { level: 6 } });
-  const stream = new PassThrough();
-  archive.pipe(stream);
-  const chunks = [];
-  const done = new Promise((resolve, reject) => {
-    stream.on("data", (chunk) => chunks.push(chunk));
-    stream.on("end", resolve);
-    stream.on("error", reject);
-    archive.on("error", reject);
+  let sizeBytes = 0;
+  const sizeGuard = new Transform({
+    transform(chunk, _encoding, callback) {
+      sizeBytes += chunk.length;
+      if (maxUploadBytes !== void 0 && sizeBytes > maxUploadBytes) {
+        callback(
+          new UploadTooLargeError(zipFilename, sizeBytes, maxUploadBytes)
+        );
+      } else {
+        callback(null, chunk);
+      }
+    }
   });
-  addGroupToArchive(archive, group, selectedSources);
-  await archive.finalize();
-  await done;
-  return Buffer.concat(chunks);
+  const output = fs9.createWriteStream(filePath, { flags: "wx", mode: 384 });
+  archive.on("warning", (err) => archive.destroy(err));
+  const done = pipeline(archive, sizeGuard, output);
+  try {
+    addGroupToArchive(archive, group, selectedSources);
+    await Promise.all([done, archive.finalize()]);
+    return sizeBytes;
+  } finally {
+    archive.destroy();
+    output.destroy();
+    await done.catch(() => {
+    });
+  }
 }
 var PlatformUploadOutput = class {
   constructor(opts) {
@@ -12177,7 +12296,6 @@ var PlatformUploadOutput = class {
   label = "Upload to hillclimb platform";
   async emit(group, options) {
     const selectedSources = new Set(options.selectedSources);
-    const buffer = await buildZipBuffer(group, selectedSources);
     const {
       client,
       projectId,
@@ -12190,76 +12308,97 @@ var PlatformUploadOutput = class {
       onContributionCreated,
       maxUploadBytes
     } = this.opts;
-    if (maxUploadBytes !== void 0 && buffer.byteLength > maxUploadBytes) {
-      throw new UploadTooLargeError(
-        zipFilename,
-        buffer.byteLength,
-        maxUploadBytes
+    const tempDir = await fs9.promises.mkdtemp(
+      path10.join(os5.tmpdir(), "hillclimb-agent-zip-")
+    );
+    const filePath = path10.join(tempDir, "snapshot.zip");
+    try {
+      const sizeBytes = await measureAgentStage(
+        "zip-create",
+        () => buildZipFile(
+          group,
+          selectedSources,
+          filePath,
+          zipFilename,
+          maxUploadBytes
+        )
       );
-    }
-    let contributionId;
-    if (existingContributionId) {
-      contributionId = existingContributionId;
-    } else {
-      const contribution = await client.createContribution(projectId, {
-        contributionTypeSlug,
-        title: contributionTitle,
-        body: contributionBody
+      appendLog(
+        "info",
+        `agent-upload: prepared archive (sizeBytes=${sizeBytes})`
+      );
+      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
       });
-      contributionId = contribution.id;
-      if (onContributionCreated) await onContributionCreated(contributionId);
-    }
-    const presigned = await client.createUpload(contributionId, {
-      originalFilename: zipFilename,
-      mimeType: "application/zip",
-      sizeBytes: buffer.byteLength
-    });
-    appendLog(
-      "info",
-      `uploading ${zipFilename} (${buffer.byteLength} bytes) to presigned URL`
-    );
-    await client.uploadToPresignedUrl(
-      presigned.presignedUrl,
-      presigned.headers,
-      buffer
-    );
-    appendLog("info", `PUT to presigned URL succeeded for ${zipFilename}`);
-    if (autoSubmit) {
-      appendLog("info", `submitting contribution ${contributionId}`);
-      try {
-        await client.submitContribution(contributionId);
-        appendLog("info", `contribution ${contributionId} submitted`);
-      } catch (err) {
-        if (err instanceof PlatformError && err.status === 409 && err.code === "CONTRIBUTION_WRONG_STATE") {
-          appendLog(
-            "info",
-            `contribution ${contributionId} was already submitted (409); continuing`
-          );
-        } else {
-          throw err;
+      appendLog(
+        "info",
+        `uploading ${zipFilename} (${sizeBytes} bytes) to presigned URL`
+      );
+      await client.uploadFileToPresignedUrl(
+        presigned.presignedUrl,
+        presigned.headers,
+        filePath,
+        sizeBytes,
+        { contributionId, uploadId: presigned.upload.id }
+      );
+      appendLog("info", `PUT to presigned URL succeeded for ${zipFilename}`);
+      if (autoSubmit) {
+        appendLog("info", `submitting contribution ${contributionId}`);
+        try {
+          await client.submitContribution(contributionId);
+          appendLog("info", `contribution ${contributionId} submitted`);
+        } catch (err) {
+          if (err instanceof PlatformError && err.status === 409 && err.code === "CONTRIBUTION_WRONG_STATE") {
+            appendLog(
+              "info",
+              `contribution ${contributionId} was already submitted (409); continuing`
+            );
+          } else {
+            throw err;
+          }
         }
       }
+      return contributionId;
+    } finally {
+      try {
+        await fs9.promises.rm(tempDir, { recursive: true, force: true });
+      } catch {
+        appendLog("warn", "agent-upload: temporary ZIP cleanup failed");
+      }
     }
-    return contributionId;
   }
 };
 
 // src/pipeline.ts
-import fs9 from "fs";
-import path10 from "path";
+import fs10 from "fs";
+import path11 from "path";
 function canonicalizePath(p7) {
-  let resolved = path10.resolve(p7);
-  if (resolved.endsWith(path10.sep) && resolved !== path10.sep) {
+  let resolved = path11.resolve(p7);
+  if (resolved.endsWith(path11.sep) && resolved !== path11.sep) {
     resolved = resolved.slice(0, -1);
   }
   return resolved;
 }
 function computeLabel(repoPath, allPaths) {
-  const segments = repoPath.split(path10.sep).filter(Boolean);
+  const segments = repoPath.split(path11.sep).filter(Boolean);
   for (let depth = 1; depth <= segments.length; depth++) {
     const label = segments.slice(-depth).join("/");
     const matches = allPaths.filter((p7) => {
-      const s = p7.split(path10.sep).filter(Boolean);
+      const s = p7.split(path11.sep).filter(Boolean);
       return s.slice(-depth).join("/") === label;
     });
     if (matches.length === 1) return label;
@@ -12281,7 +12420,7 @@ async function mergeByRepo(files) {
   const groups = [];
   for (const [repoPath, groupFiles] of grouped) {
     const stats = await Promise.all(
-      groupFiles.map((f) => fs9.promises.stat(f.absolutePath).catch(() => null))
+      groupFiles.map((f) => fs10.promises.stat(f.absolutePath).catch(() => null))
     );
     let lastModified = /* @__PURE__ */ new Date(0);
     for (const stat of stats) {
@@ -12304,7 +12443,7 @@ async function preloadFiles(group) {
     group.files.map(async (file) => {
       if (file.content) return file;
       try {
-        const buf = await fs9.promises.readFile(file.absolutePath);
+        const buf = await fs10.promises.readFile(file.absolutePath);
         const checkLen = Math.min(buf.length, 8192);
         for (let i = 0; i < checkLen; i++) {
           if (buf[i] === 0) {
@@ -12320,11 +12459,12 @@ async function preloadFiles(group) {
   return { ...group, files };
 }
 async function runPipeline(group, middleware2, output, options, onProgress) {
-  const preloaded = await preloadFiles(group);
+  const measure = output.name === "platform";
+  const preloaded = measure ? await measureAgentStage("preload", () => preloadFiles(group)) : await preloadFiles(group);
   let processed = preloaded;
   for (const mw of middleware2) {
     onProgress?.(`${mw.name} (${processed.files.length} files)`);
-    processed = await mw.process(processed);
+    processed = measure ? await measureAgentStage(mw.name, () => mw.process(processed)) : await mw.process(processed);
   }
   onProgress?.(`Compressing ${processed.files.length} files`);
   return output.emit(processed, options);
@@ -12342,7 +12482,7 @@ var STALE_LOCK_TTL_MS = 60 * 60 * 1e3;
 var EVENT_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
 var SESSION_STATE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 function stateDir() {
-  return process.env.HILLCLIMB_DEBUG_LOG_STATE_DIR ?? path11.join(configDir(), "debug-log-uploads");
+  return process.env.HILLCLIMB_DEBUG_LOG_STATE_DIR ?? path12.join(configDir(), "debug-log-uploads");
 }
 function waitMs() {
   const raw = process.env.HILLCLIMB_DEBUG_LOG_WAIT_MS;
@@ -12365,7 +12505,7 @@ async function spawnKey(payload, env = process.env) {
   if (!sessionId && !turnId && !transcriptPath) return null;
   let pin = {};
   if (eventKind2 === "stop" && !turnId && transcriptPath) {
-    const resolved = path11.resolve(transcriptPath);
+    const resolved = path12.resolve(transcriptPath);
     const raw = env[TRANSCRIPT_STAT_ENV];
     try {
       const pinned = raw ? JSON.parse(raw) : null;
@@ -12388,7 +12528,7 @@ async function spawnKey(payload, env = process.env) {
   ).digest("hex").slice(0, 32);
 }
 function spawnMarkerFile(kind, key) {
-  return path11.join(stateDir(), `spawn-${kind}-${key}`);
+  return path12.join(stateDir(), `spawn-${kind}-${key}`);
 }
 async function recordDebugLogSpawn(args) {
   if (process.env.HILLCLIMB_DEBUG_LOG_UPLOAD === "0") return;
@@ -12397,8 +12537,8 @@ async function recordDebugLogSpawn(args) {
     if (typeof payload !== "object" || payload === null) return;
     const key = await spawnKey(payload, args.env);
     if (!key) return;
-    await fs10.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
-    await fs10.promises.writeFile(spawnMarkerFile(args.kind, key), "", {
+    await fs11.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+    await fs11.promises.writeFile(spawnMarkerFile(args.kind, key), "", {
       mode: 384
     });
   } catch (err) {
@@ -12410,14 +12550,14 @@ async function recordDebugLogSpawn(args) {
 }
 async function fileExists(file) {
   try {
-    await fs10.promises.access(file);
+    await fs11.promises.access(file);
     return true;
   } catch {
     return false;
   }
 }
 function stateFile(eventId) {
-  return path11.join(stateDir(), `${eventId}.json`);
+  return path12.join(stateDir(), `${eventId}.json`);
 }
 function lockFile(eventId) {
   return `${stateFile(eventId)}.lock`;
@@ -12480,7 +12620,7 @@ function expectedKinds(tool, eventKind2, payload) {
 var TRANSCRIPT_STAT_ENV = "HILLCLIMB_DEBUG_LOG_TRANSCRIPT_STAT";
 async function statTranscriptFingerprint(resolved) {
   try {
-    const stat = await fs10.promises.stat(resolved);
+    const stat = await fs11.promises.stat(resolved);
     return {
       transcriptPath: resolved,
       transcriptMtimeMs: stat.mtimeMs,
@@ -12503,7 +12643,7 @@ function pinnedTranscriptFingerprint(resolved) {
 async function transcriptFingerprint(payload) {
   const transcriptPath = stringOrNull(payload.transcript_path);
   if (!transcriptPath) return {};
-  const resolved = path11.resolve(transcriptPath);
+  const resolved = path12.resolve(transcriptPath);
   return pinnedTranscriptFingerprint(resolved) ?? await statTranscriptFingerprint(resolved);
 }
 async function captureDebugLogParentEnv(rawPayload) {
@@ -12520,7 +12660,7 @@ async function captureDebugLogParentEnv(rawPayload) {
   }
   return {
     [TRANSCRIPT_STAT_ENV]: JSON.stringify(
-      await statTranscriptFingerprint(path11.resolve(transcriptPath))
+      await statTranscriptFingerprint(path12.resolve(transcriptPath))
     )
   };
 }
@@ -12579,7 +12719,7 @@ async function eventContext(tool, payload) {
 }
 async function readState(eventId) {
   try {
-    const raw = await fs10.promises.readFile(stateFile(eventId), "utf-8");
+    const raw = await fs11.promises.readFile(stateFile(eventId), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION) return null;
     return parsed;
@@ -12588,17 +12728,17 @@ async function readState(eventId) {
   }
 }
 async function writeState(state) {
-  await fs10.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+  await fs11.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
   const file = stateFile(state.eventId);
   const tmp = `${file}.tmp`;
-  await fs10.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+  await fs11.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
     mode: 384
   });
-  await fs10.promises.rename(tmp, file);
+  await fs11.promises.rename(tmp, file);
 }
 async function readSessionState(key) {
   try {
-    const raw = await fs10.promises.readFile(
+    const raw = await fs11.promises.readFile(
       stateFile(sessionStateId(key)),
       "utf-8"
     );
@@ -12612,26 +12752,26 @@ async function readSessionState(key) {
   }
 }
 async function writeSessionState(state) {
-  await fs10.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+  await fs11.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
   const file = stateFile(sessionStateId(state.sessionKey));
   const tmp = `${file}.tmp`;
-  await fs10.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+  await fs11.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
     mode: 384
   });
-  await fs10.promises.rename(tmp, file);
+  await fs11.promises.rename(tmp, file);
 }
 async function deleteSessionState(key) {
   try {
-    await fs10.promises.unlink(stateFile(sessionStateId(key)));
+    await fs11.promises.unlink(stateFile(sessionStateId(key)));
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
 }
 async function tryCreateLock(lockId) {
   try {
-    const fd = await fs10.promises.open(
+    const fd = await fs11.promises.open(
       lockFile(lockId),
-      fs10.constants.O_CREAT | fs10.constants.O_EXCL | fs10.constants.O_WRONLY
+      fs11.constants.O_CREAT | fs11.constants.O_EXCL | fs11.constants.O_WRONLY
     );
     try {
       await fd.write(String(process.pid));
@@ -12645,7 +12785,7 @@ async function tryCreateLock(lockId) {
   }
 }
 async function acquireLock(eventId) {
-  await fs10.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+  await fs11.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
   for (let i = 0; i < LOCK_RETRIES; i++) {
     if (await tryCreateLock(eventId)) return;
     if (await reapLockIfStale(lockFile(eventId), {
@@ -12660,7 +12800,7 @@ async function acquireLock(eventId) {
   );
 }
 async function tryAcquireLock(eventId, now) {
-  await fs10.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+  await fs11.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
   if (await tryCreateLock(eventId)) return true;
   if (await reapLockIfStale(lockFile(eventId), {
     maxAgeMs: STALE_LOCK_TTL_MS,
@@ -12673,13 +12813,13 @@ async function tryAcquireLock(eventId, now) {
 async function sweepStaleDebugLogState(now = Date.now()) {
   let entries;
   try {
-    entries = await fs10.promises.readdir(stateDir(), { withFileTypes: true });
+    entries = await fs11.promises.readdir(stateDir(), { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (!entry.isFile()) continue;
-    const file = path11.join(stateDir(), entry.name);
+    const file = path12.join(stateDir(), entry.name);
     try {
       if (entry.name.endsWith(".lock")) {
         await reapLockIfStale(file, {
@@ -12689,23 +12829,23 @@ async function sweepStaleDebugLogState(now = Date.now()) {
         continue;
       }
       if (entry.name.startsWith("session-") && entry.name.endsWith(".json")) {
-        const stat2 = await fs10.promises.stat(file);
+        const stat2 = await fs11.promises.stat(file);
         if (now - stat2.mtimeMs <= SESSION_STATE_TTL_MS) continue;
         const sessionLockId = entry.name.slice(0, -".json".length);
         if (!await tryAcquireLock(sessionLockId, now)) continue;
         try {
-          const lockedStat = await fs10.promises.stat(file);
+          const lockedStat = await fs11.promises.stat(file);
           if (now - lockedStat.mtimeMs > SESSION_STATE_TTL_MS) {
-            await fs10.promises.unlink(file);
+            await fs11.promises.unlink(file);
           }
         } finally {
           await releaseLock(sessionLockId);
         }
         continue;
       }
-      const stat = await fs10.promises.stat(file);
+      const stat = await fs11.promises.stat(file);
       if (now - stat.mtimeMs > EVENT_STATE_TTL_MS) {
-        await fs10.promises.unlink(file);
+        await fs11.promises.unlink(file);
       }
     } catch {
     }
@@ -12713,7 +12853,7 @@ async function sweepStaleDebugLogState(now = Date.now()) {
 }
 async function releaseLock(eventId) {
   try {
-    await fs10.promises.unlink(lockFile(eventId));
+    await fs11.promises.unlink(lockFile(eventId));
   } catch {
   }
 }
@@ -12729,7 +12869,7 @@ function initialState(ctx, now) {
     eventKind: ctx.eventKind,
     hookEventName: ctx.hookEventName,
     sessionId: ctx.sessionId,
-    logDate: path11.basename(todayLogPath(), ".log"),
+    logDate: path12.basename(todayLogPath(), ".log"),
     firstSeenAt: now.toISOString()
   };
 }
@@ -12816,7 +12956,7 @@ async function waitForExpectedKinds(ctx, state, ownKind) {
 }
 async function buildMiddleware(repoRoot) {
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path11.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path12.join(repoRoot, n));
   const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
   const middleware2 = [];
   if (secretResult.values.size > 0) {
@@ -12829,7 +12969,7 @@ async function uploadDebugLog(ctx, state, sessionState, onContributionCreated) {
   const logPath = todayLogPath();
   let content;
   try {
-    content = await fs10.promises.readFile(logPath);
+    content = await fs11.promises.readFile(logPath);
   } catch (err) {
     appendLog(
       "warn",
@@ -12862,7 +13002,7 @@ async function uploadDebugLog(ctx, state, sessionState, onContributionCreated) {
   };
   const group = {
     repoPath: ctx.repoRoot,
-    label: path11.basename(ctx.repoRoot),
+    label: path12.basename(ctx.repoRoot),
     files: [sourceFile],
     sourceNames: [DEBUG_LOGS_SLUG],
     lastModified: now
@@ -12885,7 +13025,7 @@ async function uploadDebugLog(ctx, state, sessionState, onContributionCreated) {
       `Tool: ${label}`,
       `Event: ${ctx.hookEventName ?? ctx.eventKind}`,
       `Repo: ${ctx.repoRoot}`,
-      `Log: ${path11.basename(logPath)}`,
+      `Log: ${path12.basename(logPath)}`,
       `Agent done: ${state.agentDoneAt ?? "<not observed>"}`,
       `Git done: ${state.gitDoneAt ?? "<not observed>"}`,
       `Uploaded: ${now.toISOString()}`
@@ -12918,7 +13058,7 @@ async function uploadDebugLog(ctx, state, sessionState, onContributionCreated) {
     );
     appendLog(
       "info",
-      `debug-logs: uploaded ${path11.basename(logPath)} to project ${ctx.config.projectSlug} (${ctx.config.projectId}) as contribution ${contributionId}`
+      `debug-logs: uploaded ${path12.basename(logPath)} to project ${ctx.config.projectSlug} (${ctx.config.projectId}) as contribution ${contributionId}`
     );
     return { kind: "uploaded", contributionId };
   } catch (err) {
@@ -13079,14 +13219,15 @@ async function uploadArtifact(client, contributionId, filename, mimeType, buffer
   await client.uploadToPresignedUrl(
     presigned.presignedUrl,
     presigned.headers,
-    buffer
+    buffer,
+    { contributionId, uploadId: presigned.upload.id }
   );
   appendLog("info", `PUT to presigned URL succeeded for ${filename}`);
 }
 
 // src/transcript-cursor.ts
 import crypto3 from "crypto";
-import fs11 from "fs";
+import fs12 from "fs";
 function sha256OfBuffer(buffer) {
   return crypto3.createHash("sha256").update(buffer).digest("hex");
 }
@@ -13094,7 +13235,7 @@ async function hashPrefix(filePath, byteLength) {
   const hash = crypto3.createHash("sha256");
   if (byteLength === 0) return hash;
   await new Promise((resolve, reject) => {
-    const stream = fs11.createReadStream(filePath, {
+    const stream = fs12.createReadStream(filePath, {
       start: 0,
       end: byteLength - 1
     });
@@ -13105,7 +13246,7 @@ async function hashPrefix(filePath, byteLength) {
   return hash;
 }
 async function readRange(filePath, start, end) {
-  const fd = await fs11.promises.open(filePath, "r");
+  const fd = await fs12.promises.open(filePath, "r");
   try {
     const buffer = Buffer.alloc(end - start);
     let filled = 0;
@@ -13125,15 +13266,21 @@ async function readRange(filePath, start, end) {
   }
 }
 async function evaluateTranscript(filePath, cursor) {
-  const stat = await fs11.promises.stat(filePath);
+  const stat = await fs12.promises.stat(filePath);
   if (stat.size < cursor.rawByteOffset) return { kind: "truncate" };
-  const prefixHash = await hashPrefix(filePath, cursor.rawByteOffset);
+  const prefixHash = await measureAgentStage(
+    "cursor-prefix-hash",
+    () => hashPrefix(filePath, cursor.rawByteOffset)
+  );
   const continuation = prefixHash.copy();
   if (prefixHash.digest("hex") !== cursor.rawPrefixSha256) {
     return { kind: "rewrite" };
   }
   if (stat.size === cursor.rawByteOffset) return { kind: "unchanged" };
-  const grown = await readRange(filePath, cursor.rawByteOffset, stat.size);
+  const grown = await measureAgentStage(
+    "transcript-tail-read",
+    () => readRange(filePath, cursor.rawByteOffset, stat.size)
+  );
   const lastNewline = grown.lastIndexOf(10);
   if (lastNewline === -1) return { kind: "unchanged" };
   const tail = grown.subarray(0, lastNewline + 1);
@@ -13160,12 +13307,15 @@ function truncateAtLastNewline(buffer) {
 }
 async function cursorMatchesFile(filePath, cursor) {
   try {
-    const stat = await fs11.promises.stat(filePath);
+    const stat = await fs12.promises.stat(filePath);
     if (stat.size < cursor.rawByteOffset) return false;
-    const prefixHash = await hashPrefix(filePath, cursor.rawByteOffset);
+    const prefixHash = await measureAgentStage(
+      "legacy-prefix-hash",
+      () => hashPrefix(filePath, cursor.rawByteOffset)
+    );
     if (prefixHash.digest("hex") !== cursor.rawPrefixSha256) return false;
     if (cursor.rawByteOffset === 0) return true;
-    const fd = await fs11.promises.open(filePath, "r");
+    const fd = await fs12.promises.open(filePath, "r");
     try {
       const byte = Buffer.alloc(1);
       const { bytesRead } = await fd.read(byte, 0, 1, cursor.rawByteOffset - 1);
@@ -13180,19 +13330,20 @@ async function cursorMatchesFile(filePath, cursor) {
 
 // src/upload-state.ts
 import crypto4 from "crypto";
-import fs12 from "fs";
-import os5 from "os";
-import path12 from "path";
+import fs13 from "fs";
+import os6 from "os";
+import path13 from "path";
 var CURRENT_SCHEMA_VERSION2 = 1;
-var DEFAULT_STATE_DIR = path12.join(
-  os5.homedir(),
+var DEFAULT_STATE_DIR = path13.join(
+  os6.homedir(),
   ".hillclimb",
   "agent-uploads"
 );
 var DEFAULT_LOCK_WAIT_MS2 = 5 * 60 * 1e3;
+var DEFAULT_LIVE_OWNER_MAX_WAIT_MS = 4 * 60 * 60 * 1e3;
 var DEFAULT_LOCK_RETRY_DELAY_MS = 500;
 var DEFAULT_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
-var STALE_LOCK_TTL_MS2 = 60 * 60 * 1e3;
+var STALE_LOCK_TTL_MS2 = DEFAULT_LIVE_OWNER_MAX_WAIT_MS;
 function stateDir2() {
   return process.env.HILLCLIMB_UPLOAD_STATE_DIR ?? DEFAULT_STATE_DIR;
 }
@@ -13208,6 +13359,13 @@ function stateTtlMs() {
     DEFAULT_STATE_TTL_MS
   );
 }
+function staleLockTtlMs() {
+  return Math.max(
+    STALE_LOCK_TTL_MS2,
+    readPositiveEnvMs("HILLCLIMB_UPLOAD_LOCK_LIVE_OWNER_MAX_WAIT_MS", 0),
+    readPositiveEnvMs("HILLCLIMB_UPLOAD_LOCK_WAIT_MS", 0)
+  );
+}
 function lockRetryDelayMs() {
   return Math.max(
     1,
@@ -13226,15 +13384,15 @@ function lockRetries() {
   );
 }
 function stateFileFor(repoRoot, tool, sessionId) {
-  const hash = crypto4.createHash("sha256").update(`${path12.resolve(repoRoot)}\0${tool}\0${sessionId}`).digest("hex").slice(0, 16);
-  return path12.join(stateDir2(), `${hash}.json`);
+  const hash = crypto4.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 fs12.promises.readFile(
+    const raw = await fs13.promises.readFile(
       stateFileFor(repoRoot, tool, sessionId),
       "utf-8"
     );
@@ -13246,21 +13404,23 @@ async function readUploadState(repoRoot, tool, sessionId) {
   }
 }
 async function writeUploadState(state) {
-  const file = stateFileFor(state.repoRoot, state.tool, state.sessionId);
-  await fs12.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
-  const tmp = `${file}.tmp`;
-  await fs12.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
-    mode: 384
+  await measureAgentStage("state-persist", async () => {
+    const file = stateFileFor(state.repoRoot, state.tool, state.sessionId);
+    await fs13.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+    const tmp = `${file}.tmp`;
+    await fs13.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+      mode: 384
+    });
+    await fs13.promises.rename(tmp, file);
   });
-  await fs12.promises.rename(tmp, file);
 }
 async function deleteUploadState(repoRoot, tool, sessionId) {
   try {
-    await fs12.promises.unlink(stateFileFor(repoRoot, tool, sessionId));
+    await fs13.promises.unlink(stateFileFor(repoRoot, tool, sessionId));
   } catch {
   }
   try {
-    await fs12.promises.unlink(cursorFileFor(repoRoot, tool, sessionId));
+    await fs13.promises.unlink(cursorFileFor(repoRoot, tool, sessionId));
   } catch {
   }
 }
@@ -13269,7 +13429,7 @@ function cursorFileFor(repoRoot, tool, sessionId) {
 }
 async function readCursorState(repoRoot, tool, sessionId) {
   try {
-    const raw = await fs12.promises.readFile(
+    const raw = await fs13.promises.readFile(
       cursorFileFor(repoRoot, tool, sessionId),
       "utf-8"
     );
@@ -13283,13 +13443,15 @@ async function readCursorState(repoRoot, tool, sessionId) {
   }
 }
 async function writeCursorState(repoRoot, tool, sessionId, cursor) {
-  const file = cursorFileFor(repoRoot, tool, sessionId);
-  await fs12.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
-  const tmp = `${file}.tmp`;
-  await fs12.promises.writeFile(tmp, JSON.stringify(cursor, null, 2), {
-    mode: 384
+  await measureAgentStage("cursor-persist", async () => {
+    const file = cursorFileFor(repoRoot, tool, sessionId);
+    await fs13.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+    const tmp = `${file}.tmp`;
+    await fs13.promises.writeFile(tmp, JSON.stringify(cursor, null, 2), {
+      mode: 384
+    });
+    await fs13.promises.rename(tmp, file);
   });
-  await fs12.promises.rename(tmp, file);
 }
 async function setUploadSessionEndedAt(repoRoot, tool, sessionId, sessionEndedAt) {
   const state = await readUploadState(repoRoot, tool, sessionId);
@@ -13297,7 +13459,7 @@ async function setUploadSessionEndedAt(repoRoot, tool, sessionId, sessionEndedAt
   await writeUploadState({ ...state, sessionEndedAt });
   const now = /* @__PURE__ */ new Date();
   try {
-    await fs12.promises.utimes(
+    await fs13.promises.utimes(
       cursorFileFor(repoRoot, tool, sessionId),
       now,
       now
@@ -13306,14 +13468,23 @@ async function setUploadSessionEndedAt(repoRoot, tool, sessionId, sessionEndedAt
   }
   return true;
 }
-async function acquireLock2(repoRoot, tool, sessionId, retries = lockRetries(), delayMs = lockRetryDelayMs()) {
+async function acquireLock2(repoRoot, tool, sessionId, retries, delayMs = lockRetryDelayMs(), options = {}) {
   const lockPath = lockFileFor(repoRoot, tool, sessionId);
-  await fs12.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
-  for (let i = 0; i < retries; i++) {
+  const maxRetries = retries ?? lockRetries();
+  const maxWaitMs = options.liveOwnerMaxWaitMs ?? (retries !== void 0 || process.env.HILLCLIMB_UPLOAD_LOCK_WAIT_MS !== void 0 ? 0 : readPositiveEnvMs(
+    "HILLCLIMB_UPLOAD_LOCK_LIVE_OWNER_MAX_WAIT_MS",
+    DEFAULT_LIVE_OWNER_MAX_WAIT_MS
+  ));
+  const started = Date.now();
+  let extended = false;
+  let attempts = 0;
+  await fs13.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+  for (; ; ) {
+    attempts++;
     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
       );
       try {
         await fd.write(String(process.pid));
@@ -13322,31 +13493,43 @@ async function acquireLock2(repoRoot, tool, sessionId, retries = lockRetries(),
       }
       return;
     } catch (err) {
-      if (err.code === "EEXIST" && i < retries - 1) {
-        if (await reapLockIfStale(lockPath, {
-          maxAgeMs: STALE_LOCK_TTL_MS2
-        })) {
-          continue;
-        }
-        await new Promise((r) => setTimeout(r, delayMs));
+      if (err.code !== "EEXIST") throw err;
+      if (await reapLockIfStale(lockPath, {
+        maxAgeMs: Math.max(staleLockTtlMs(), maxWaitMs),
+        preserveLiveOwner: true
+      }))
         continue;
+      if (attempts >= maxRetries) {
+        if (Date.now() - started >= maxWaitMs) break;
+        const owner = await probeLockOwner(lockPath);
+        if (!owner) continue;
+        if (!owner.alive) break;
+        if (!extended) {
+          appendLog(
+            "info",
+            `agent-upload: extending lock wait for live owner (pid=${owner.pid ?? "unwritten"}, maxWaitMs=${maxWaitMs})`
+          );
+          extended = true;
+        }
       }
-      if (err.code === "EEXIST") break;
-      throw err;
+      await new Promise((r) => setTimeout(r, delayMs));
     }
   }
   throw new Error(
-    `Failed to acquire upload lock for ${tool} session ${sessionId} after ${retries} retries (${delayMs}ms delay, lock=${lockPath})`
+    `Failed to acquire upload lock for ${tool} session ${sessionId} after ${attempts} retries (${Date.now() - started}ms elapsed, ${delayMs}ms delay, lock=${lockPath})`
   );
 }
 async function releaseLock2(repoRoot, tool, sessionId) {
   try {
-    await fs12.promises.unlink(lockFileFor(repoRoot, tool, sessionId));
+    await fs13.promises.unlink(lockFileFor(repoRoot, tool, sessionId));
   } catch {
   }
 }
 async function withUploadLock(repoRoot, tool, sessionId, fn) {
-  await acquireLock2(repoRoot, tool, sessionId);
+  await measureAgentStage(
+    "lock-wait",
+    () => acquireLock2(repoRoot, tool, sessionId)
+  );
   try {
     return await fn();
   } finally {
@@ -13356,30 +13539,37 @@ async function withUploadLock(repoRoot, tool, sessionId, fn) {
 async function sweepStaleUploadStates(ttlMs = stateTtlMs(), now = Date.now()) {
   let entries;
   try {
-    entries = await fs12.promises.readdir(stateDir2(), { withFileTypes: true });
+    entries = await fs13.promises.readdir(stateDir2(), { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (!entry.isFile()) continue;
-    const file = path12.join(stateDir2(), entry.name);
+    const file = path13.join(stateDir2(), entry.name);
     try {
       if (entry.name.endsWith(".lock")) {
         await reapLockIfStale(file, {
-          maxAgeMs: STALE_LOCK_TTL_MS2,
+          maxAgeMs: staleLockTtlMs(),
+          preserveLiveOwner: true,
           now
         });
         continue;
       }
-      const st = await fs12.promises.stat(file);
+      const st = await fs13.promises.stat(file);
       if (now - st.mtimeMs > ttlMs) {
-        await fs12.promises.unlink(file);
+        await fs13.promises.unlink(file);
       }
     } catch {
     }
   }
 }
 
+// package.json
+var version = "0.8.11";
+
+// src/version.ts
+var CLI_VERSION = version;
+
 // src/commands/upload.ts
 async function readStdin() {
   if (process.stdin.isTTY) return "";
@@ -13399,7 +13589,7 @@ function lineHasAssistant(line) {
   return line.includes('"type":"assistant"') || line.includes('"role":"assistant"') || line.includes('"type":"assistant.');
 }
 async function hasAssistantMessage(transcriptPath) {
-  const stream = fs13.createReadStream(transcriptPath, { encoding: "utf-8" });
+  const stream = fs14.createReadStream(transcriptPath, { encoding: "utf-8" });
   let buffer = "";
   try {
     for await (const chunk of stream) {
@@ -13486,8 +13676,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(
-    os6.homedir(),
+  return path14.join(
+    os7.homedir(),
     ".cursor",
     "projects",
     encoded,
@@ -13562,9 +13752,9 @@ async function runUploadInner(payload) {
     );
     return "skipped";
   }
-  const transcriptResolved = path13.resolve(transcriptPath);
+  const transcriptResolved = path14.resolve(transcriptPath);
   try {
-    const stat = await fs13.promises.stat(transcriptResolved);
+    const stat = await fs14.promises.stat(transcriptResolved);
     if (!stat.isFile()) {
       appendLog(
         "warn",
@@ -13607,7 +13797,6 @@ async function runUploadInner(payload) {
   return uploaded ? "uploaded" : "skipped";
 }
 var AGENT_MAX_UPLOAD_BYTES = 1024 * 1024 * 1024;
-var CLI_VERSION = "0.8.0";
 function makeTranscriptGroup(repoRoot, sourceTool, transcriptPath, content) {
   const sourceFile = {
     sourceName: sourceTool,
@@ -13617,16 +13806,22 @@ function makeTranscriptGroup(repoRoot, sourceTool, transcriptPath, content) {
   };
   return {
     repoPath: repoRoot,
-    label: path13.basename(repoRoot),
+    label: path14.basename(repoRoot),
     files: [sourceFile],
     sourceNames: [sourceTool],
     lastModified: /* @__PURE__ */ new Date()
   };
 }
 async function buildRedactChain(repoRoot) {
-  const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path13.join(repoRoot, n));
-  const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
+  const envFileNames = await measureAgentStage(
+    "secret-discovery",
+    () => discoverEnvFiles(repoRoot)
+  );
+  const envFilePaths = envFileNames.map((n) => path14.join(repoRoot, n));
+  const secretResult = await measureAgentStage(
+    "secret-collection",
+    () => collectSecrets(repoRoot, envFilePaths, [])
+  );
   const chain = [];
   if (secretResult.values.size > 0) {
     chain.push(new RedactMiddleware(secretResult.values));
@@ -13637,7 +13832,7 @@ async function buildRedactChain(repoRoot) {
 async function redactTail(tail, repoRoot, sourceTool, transcriptPath, redactChain) {
   let group = makeTranscriptGroup(repoRoot, sourceTool, transcriptPath, tail);
   for (const mw of redactChain) {
-    group = await mw.process(group);
+    group = await measureAgentStage(mw.name, () => mw.process(group));
   }
   const file = group.files.find((f) => f.absolutePath === transcriptPath);
   if (!file?.content) {
@@ -13702,8 +13897,14 @@ async function uploadSession(args) {
   const isSessionEnd = eventKind2 === "sessionEnd";
   const eventLabel = isSessionEnd ? "SessionEnd" : "Stop";
   return await withUploadLock(repoRoot, sourceTool, sessionId, async () => {
-    const prior = await readUploadState(repoRoot, sourceTool, sessionId);
-    const lineageDetection = sourceTool === "codex" && prior?.codexLineageChecked !== true ? await detectCodexLineage(transcriptPath) : void 0;
+    const prior = await measureAgentStage(
+      "state-read",
+      () => readUploadState(repoRoot, sourceTool, sessionId)
+    );
+    const lineageDetection = sourceTool === "codex" && prior?.codexLineageChecked !== true ? await measureAgentStage(
+      "lineage-detection",
+      () => detectCodexLineage(transcriptPath)
+    ) : void 0;
     const codexLineage = sourceTool === "codex" ? mergeCodexLineage(prior?.codexLineage, lineageDetection?.lineage) : void 0;
     const codexLineageChecked = sourceTool === "codex" ? prior?.codexLineageChecked === true || lineageDetection?.conclusive === true : void 0;
     const lineageNeedsStamp = codexLineage !== void 0 && JSON.stringify(codexLineage) !== JSON.stringify(prior?.codexLineageStamped);
@@ -13715,6 +13916,7 @@ async function uploadSession(args) {
       });
     }
     let cursor = null;
+    let snapshotReason = !prior ? "first-upload" : !prior.contributionId ? "missing-contribution" : prior.snapshotUploaded === false || prior.uploadCount === 0 ? "incomplete-baseline" : "missing-cursor-fields";
     let adoptedLegacy = false;
     let restored = null;
     if (prior?.contributionId && prior.snapshotUploaded && prior.rawByteOffset !== void 0 && prior.rawPrefixSha256 !== void 0) {
@@ -13725,6 +13927,7 @@ async function uploadSession(args) {
     } else if (prior?.contributionId && prior.rawByteOffset === void 0) {
       const sidecar = await readCursorState(repoRoot, sourceTool, sessionId);
       if (sidecar && sidecar.contributionId !== prior.contributionId) {
+        snapshotReason = "sidecar-contribution-mismatch";
         appendLog(
           "info",
           `[${sessionId}] ignoring sidecar cursor for stale contribution ${sidecar.contributionId} (state has ${prior.contributionId})`
@@ -13745,7 +13948,10 @@ async function uploadSession(args) {
           rawByteOffset: prior.lastTranscriptSize,
           rawPrefixSha256: prior.lastTranscriptSha256
         };
-        if (await cursorMatchesFile(transcriptPath, candidate)) {
+        if (await measureAgentStage(
+          "legacy-cursor-validation",
+          () => cursorMatchesFile(transcriptPath, candidate)
+        )) {
           cursor = candidate;
           adoptedLegacy = true;
           appendLog(
@@ -13753,6 +13959,7 @@ async function uploadSession(args) {
             `[${sessionId}] adopting last uploaded full zip as epoch-001 baseline (legacy state bootstrap, offset=${candidate.rawByteOffset})`
           );
         } else {
+          snapshotReason = "legacy-prefix-mismatch-or-incomplete-line";
           appendLog(
             "info",
             `[${sessionId}] legacy state present but prefix mismatch or mid-line offset (offset=${candidate.rawByteOffset}) \u2014 will re-baseline with a fresh snapshot`
@@ -13765,13 +13972,18 @@ async function uploadSession(args) {
     let tail;
     let nextCursor;
     if (cursor) {
-      const evaluation = await evaluateTranscript(transcriptPath, cursor);
+      const currentCursor = cursor;
+      const evaluation = await measureAgentStage(
+        "cursor-validation-and-tail-read",
+        () => evaluateTranscript(transcriptPath, currentCursor)
+      );
       if (evaluation.kind === "unchanged") {
         if (lineageNeedsStamp && prior?.contributionId && prior.epochMeta) {
           mode = "meta-refresh";
         } else if (lineageNeedsStamp) {
           mode = "snapshot";
           transition = "state-lost";
+          snapshotReason = "lineage-metadata-unavailable";
         } else {
           appendLog(
             "info",
@@ -13801,6 +14013,7 @@ async function uploadSession(args) {
       } else {
         mode = "snapshot";
         transition = evaluation.kind;
+        snapshotReason = evaluation.kind;
       }
     } else {
       mode = "snapshot";
@@ -13935,7 +14148,7 @@ async function uploadSession(args) {
           contributionId2,
           patchFilename(epoch2, turn, recordedAt),
           "application/gzip",
-          gzipPatch(redactedTail),
+          measureAgentSyncStage("patch-gzip", () => gzipPatch(redactedTail)),
           AGENT_MAX_UPLOAD_BYTES
         );
       } catch (err) {
@@ -14063,7 +14276,10 @@ async function uploadSession(args) {
     }
     let raw;
     try {
-      raw = await fs13.promises.readFile(transcriptPath);
+      raw = await measureAgentStage(
+        "transcript-read",
+        () => fs14.promises.readFile(transcriptPath)
+      );
     } catch (err) {
       if (err.code === "ERR_FS_FILE_TOO_LARGE") {
         appendLog(
@@ -14078,7 +14294,10 @@ async function uploadSession(args) {
       }
       return false;
     }
-    const truncated = truncateAtLastNewline(raw);
+    const truncated = measureAgentSyncStage(
+      "snapshot-cursor-hash",
+      () => truncateAtLastNewline(raw)
+    );
     if (!truncated) {
       appendLog(
         "info",
@@ -14168,7 +14387,7 @@ Uploaded: ${now.toISOString()}`;
     const reuseDesc = prior?.contributionId ? `reusing contribution ${prior.contributionId}` : prior ? "new contribution (prior state had no contribution \u2014 earlier create may have failed)" : "new contribution (first upload for session)";
     appendLog(
       "info",
-      `[${sessionId}] ${sourceTool} ${eventLabel} upload \u2192 snapshot epoch=${epoch} transition=${transition} (${truncated.covered.length} raw bytes, ${reuseDesc})`
+      `[${sessionId}] ${sourceTool} ${eventLabel} upload \u2192 snapshot epoch=${epoch} transition=${transition} reason=${snapshotReason} (${truncated.covered.length} raw bytes, ${reuseDesc})`
     );
     let contributionId;
     try {
@@ -14335,7 +14554,10 @@ async function runUpload() {
 }
 async function runUploadWorker() {
   setLogPrefix(`[${process.env[FLOW_ID_ENV] ?? newFlowId()}]`);
-  appendLog("info", `upload worker started (pid ${process.pid})`);
+  appendLog(
+    "info",
+    `upload worker started (pid ${process.pid}, cliVersion=${CLI_VERSION})`
+  );
   let raw;
   try {
     raw = await readStdin();
@@ -14393,28 +14615,28 @@ import crypto7 from "crypto";
 
 // src/git-traces/handlers.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import fs16 from "fs";
-import path16 from "path";
+import fs17 from "fs";
+import path17 from "path";
 
 // src/git-traces/git-ops.ts
 import { execFileSync as execFileSync2, spawn as spawn3, spawnSync } from "child_process";
-import fs14 from "fs";
-import os7 from "os";
-import path14 from "path";
+import fs15 from "fs";
+import os8 from "os";
+import path15 from "path";
 import { createGzip } from "zlib";
 
 // src/git-traces/timing.ts
-import { performance } from "perf_hooks";
+import { performance as performance2 } from "perf_hooks";
 function startCaptureStage(stage, context) {
   appendLog(
     "info",
     `git-traces: capture timing (${context}, stage=${stage}, status=started)`
   );
-  const started = performance.now();
+  const started = performance2.now();
   return (status) => {
     appendLog(
       "info",
-      `git-traces: capture timing (${context}, stage=${stage}, status=${status}, elapsedMs=${Math.round(performance.now() - started)})`
+      `git-traces: capture timing (${context}, stage=${stage}, status=${status}, elapsedMs=${Math.round(performance2.now() - started)})`
     );
   };
 }
@@ -14432,12 +14654,13 @@ function timeCaptureStage(repoRoot, stage, run) {
 
 // src/git-traces/git-ops.ts
 var DEFAULT_GIT_COMMAND_TIMEOUT_MS = 12e4;
+var DEFAULT_BUNDLE_TIMEOUT_MS = 3e5;
 var FULL_TREE_SCAN_TIMEOUT_MS = 3e5;
-function resolveGitCommandTimeoutMs() {
+function resolveGitCommandTimeoutMs(fallback = DEFAULT_GIT_COMMAND_TIMEOUT_MS) {
   const raw = process.env.HILLCLIMB_GIT_COMMAND_TIMEOUT_MS;
-  if (!raw) return DEFAULT_GIT_COMMAND_TIMEOUT_MS;
+  if (!raw) return fallback;
   const parsed = Number(raw);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_GIT_COMMAND_TIMEOUT_MS;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 var GIT_COMMAND_TIMEOUT_MS = resolveGitCommandTimeoutMs();
 var EXEC_OPTS = {
@@ -14620,8 +14843,8 @@ var EXCLUDED_SNAPSHOT_BASENAMES = /* @__PURE__ */ new Set([
 ]);
 var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 function isExcludedSnapshotPath(filePath) {
-  if (EXCLUDED_SNAPSHOT_BASENAMES.has(path14.basename(filePath))) return true;
-  return EXCLUDED_SNAPSHOT_EXTENSIONS.has(path14.extname(filePath).toLowerCase());
+  if (EXCLUDED_SNAPSHOT_BASENAMES.has(path15.basename(filePath))) return true;
+  return EXCLUDED_SNAPSHOT_EXTENSIONS.has(path15.extname(filePath).toLowerCase());
 }
 function isBinaryBuffer(buffer) {
   return buffer.includes(0);
@@ -14642,16 +14865,16 @@ function readTreeBlobHead(repoRoot, sha) {
 function readWorkingFileHead(absPath) {
   let fd = null;
   try {
-    fd = fs14.openSync(absPath, "r");
+    fd = fs15.openSync(absPath, "r");
     const buffer = Buffer.alloc(BINARY_SNIFF_BYTES);
-    const bytesRead = fs14.readSync(fd, buffer, 0, BINARY_SNIFF_BYTES, 0);
+    const bytesRead = fs15.readSync(fd, buffer, 0, BINARY_SNIFF_BYTES, 0);
     return buffer.subarray(0, bytesRead);
   } catch {
     return null;
   } finally {
     if (fd !== null) {
       try {
-        fs14.closeSync(fd);
+        fs15.closeSync(fd);
       } catch {
       }
     }
@@ -14711,9 +14934,11 @@ function createGitError(args, err, timeoutMs = GIT_COMMAND_TIMEOUT_MS) {
   const message = isTimeout ? `${command} timed out after ${timeoutMs}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;
-  wrapped.gitExitStatus = failure.status;
+  wrapped.gitExitStatus = failure.code || failure.signal ? void 0 : failure.status;
   const stderr = outputToString(failure.stderr);
   wrapped.gitStderr = stderr ? truncateOutput(stderr) : void 0;
+  const stdout = outputToString(failure.stdout);
+  wrapped.gitStdout = stdout ? truncateOutput(stdout) : void 0;
   wrapped.isGitMissingObject = !isTimeout && failure.code !== "ENOBUFS" && matchesMissingObject(stderr);
   return wrapped;
 }
@@ -14752,6 +14977,19 @@ function isGitRepo(dir) {
     return false;
   }
 }
+function stashRetryReason(failure) {
+  const status = failure.gitExitStatus;
+  if (status !== 1 && status !== 128) return null;
+  if (/Unable to create [^\n]*index\.lock[^\n]*: File exists/.test(
+    failure.gitStderr ?? ""
+  )) {
+    return "index-lock-contention";
+  }
+  if (status === 1 && !failure.gitStderr && !failure.gitStdout) {
+    return "empty-stash-failure";
+  }
+  return null;
+}
 function captureWorkingCommitSha(repoRoot) {
   for (let attempt = 1; ; attempt++) {
     let sha;
@@ -14778,11 +15016,11 @@ function captureWorkingCommitSha(repoRoot) {
         const tree = git(repoRoot, ["write-tree"]);
         return git(repoRoot, ["commit-tree", tree, "-m", "empty baseline"]);
       }
-      if (failure.gitExitStatus !== 1 || !/Unable to create [^\n]*index\.lock[^\n]*: File exists/.test(stderr) || attempt >= 5)
-        throw err;
+      const retryReason = stashRetryReason(failure);
+      if (!retryReason || attempt >= 5) throw err;
       appendLog(
         "warn",
-        `git-traces: retrying stash create after index lock contention (repo=${repoRoot}, attempt=${attempt}, maxAttempts=5): ${failure.message}`
+        `git-traces: retrying stash create after ${retryReason === "index-lock-contention" ? "index lock contention" : "empty Git failure (possible index contention)"} (repo=${repoRoot}, attempt=${attempt}, maxAttempts=5, reason=${retryReason}): ${failure.message}`
       );
       Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 250);
       continue;
@@ -15044,8 +15282,8 @@ function filterOmittedFilesFromTree(repoRoot, treeSha, options = {}) {
   options.omittedFiles?.push(...omittedFiles);
   return timeCaptureStage(repoRoot, "tracked-tree-filter", () => {
     if (omittedFiles.length === 0) return treeSha;
-    const tmpIndex = path14.join(
-      os7.tmpdir(),
+    const tmpIndex = path15.join(
+      os8.tmpdir(),
       `hillclimb-filter-${Date.now()}-${process.pid}`
     );
     const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -15059,7 +15297,7 @@ function filterOmittedFilesFromTree(repoRoot, treeSha, options = {}) {
       return gitWithEnv(repoRoot, ["write-tree"], env);
     } finally {
       try {
-        fs14.unlinkSync(tmpIndex);
+        fs15.unlinkSync(tmpIndex);
       } catch {
       }
     }
@@ -15083,8 +15321,8 @@ function buildUntrackedTree(repoRoot, options = {}) {
       if (!relPath) continue;
       candidates++;
       try {
-        const absPath = path14.join(repoRoot, relPath);
-        const stat = fs14.lstatSync(absPath);
+        const absPath = path15.join(repoRoot, relPath);
+        const stat = fs15.lstatSync(absPath);
         const reason = classifyOmission(
           relPath,
           stat.size,
@@ -15115,8 +15353,8 @@ function buildUntrackedTree(repoRoot, options = {}) {
     `git-traces: untracked inventory (repo=${repoRoot}, candidates=${candidates}, kept=${kept.length}, keptBytes=${keptBytes}, omitted=${omitted}, omittedBytes=${omittedBytes}, skipped=${skipped})`
   );
   if (kept.length === 0) return null;
-  const tmpIndex = path14.join(
-    os7.tmpdir(),
+  const tmpIndex = path15.join(
+    os8.tmpdir(),
     `hillclimb-untracked-${Date.now()}-${process.pid}`
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -15136,7 +15374,7 @@ function buildUntrackedTree(repoRoot, options = {}) {
     );
   } finally {
     try {
-      fs14.unlinkSync(tmpIndex);
+      fs15.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -15166,14 +15404,38 @@ function buildSnapshotTree(repoRoot, stashSha, options = {}) {
     () => buildUntrackedTree(repoRoot, { omittedFiles, limits })
   );
   if (options.log !== false) logOmittedSnapshotSummary(omittedFiles);
-  const snapshotTree = timeCaptureStage(
-    repoRoot,
-    "tree-assembly",
-    () => mergeSnapshotTrees(repoRoot, filteredTrackedTree, untrackedTree)
-  );
+  const snapshotTree = timeCaptureStage(repoRoot, "tree-assembly", () => {
+    const previous = usableOmissionScan(options.previousScan, limits);
+    if (untrackedTree && untrackedTree !== EMPTY_TREE_SHA && filteredTrackedTree !== EMPTY_TREE_SHA && previous?.assembly?.trackedTreeSha === filteredTrackedTree && previous.assembly.untrackedTreeSha === untrackedTree) {
+      try {
+        gitBuffer(repoRoot, [
+          "rev-list",
+          "--objects",
+          "--missing=error",
+          previous.snapshotTreeSha,
+          "--"
+        ]);
+        appendLog(
+          "info",
+          `git-traces: tree assembly reused (repo=${repoRoot})`
+        );
+        return previous.snapshotTreeSha;
+      } catch {
+        appendLog(
+          "info",
+          `git-traces: tree assembly cache unavailable; rebuilding (repo=${repoRoot})`
+        );
+      }
+    }
+    return mergeSnapshotTrees(repoRoot, filteredTrackedTree, untrackedTree);
+  });
   options.scanOut?.push({
     trackedTreeSha: trackedTree,
     snapshotTreeSha: snapshotTree,
+    assembly: {
+      trackedTreeSha: filteredTrackedTree,
+      untrackedTreeSha: untrackedTree
+    },
     limits,
     omittedFiles: trackedOmitted
   });
@@ -15182,8 +15444,9 @@ function buildSnapshotTree(repoRoot, stashSha, options = {}) {
 function mergeSnapshotTrees(repoRoot, filteredTrackedTree, untrackedTree) {
   if (!untrackedTree || untrackedTree === EMPTY_TREE_SHA)
     return filteredTrackedTree;
-  const tmpIndex = path14.join(
-    os7.tmpdir(),
+  if (filteredTrackedTree === EMPTY_TREE_SHA) return untrackedTree;
+  const tmpIndex = path15.join(
+    os8.tmpdir(),
     `hillclimb-index-${Date.now()}-${process.pid}`
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -15232,7 +15495,7 @@ function mergeSnapshotTrees(repoRoot, filteredTrackedTree, untrackedTree) {
     );
   } finally {
     try {
-      fs14.unlinkSync(tmpIndex);
+      fs15.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -15246,19 +15509,28 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
   ]);
   const orphanRef = `refs/hillclimb/bundle/${sessionId}`;
   pinRef(repoRoot, orphanRef, orphanCommit);
-  const tmpFile = path14.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`
-  );
+  let tmpDir;
   try {
-    git(repoRoot, ["bundle", "create", tmpFile, orphanRef]);
-    return fs14.readFileSync(tmpFile);
+    tmpDir = fs15.mkdtempSync(
+      path15.join(os8.tmpdir(), `hillclimb-bundle-${process.pid}-`)
+    );
+    const tmpFile = path15.join(tmpDir, "baseline.bundle");
+    timeCaptureStage(
+      repoRoot,
+      "bundle-create",
+      () => gitBuffer(repoRoot, ["bundle", "create", tmpFile, orphanRef], {
+        timeoutMs: resolveGitCommandTimeoutMs(DEFAULT_BUNDLE_TIMEOUT_MS)
+      })
+    );
+    const bundle = fs15.readFileSync(tmpFile);
+    appendLog(
+      "info",
+      `git-traces: bundle inventory (repo=${repoRoot}, bytes=${bundle.length})`
+    );
+    return bundle;
   } finally {
     try {
-      fs14.unlinkSync(tmpFile);
+      if (tmpDir) fs15.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
     deleteRef(repoRoot, orphanRef);
@@ -15456,7 +15728,7 @@ function buildBaselineMetadata(repoRoot, sessionId, tool, baselineSha, cliVersio
       ...omittedFiles.length > 0 ? { omittedFiles } : {}
     },
     author: { name: authorName, email: authorEmail },
-    hostname: os7.hostname(),
+    hostname: os8.hostname(),
     cliVersion,
     commits,
     ...lineage,
@@ -15548,9 +15820,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")) {
@@ -15630,14 +15902,14 @@ function countScopedTurnTreeRefs(repoRoot, sessionId, epochPrefix3) {
 
 // src/git-traces/session-state.ts
 import crypto6 from "crypto";
-import fs15 from "fs";
-import os8 from "os";
-import path15 from "path";
+import fs16 from "fs";
+import os9 from "os";
+import path16 from "path";
 var CURRENT_SCHEMA_VERSION3 = 3;
-var DEFAULT_STATE_DIR2 = path15.join(os8.homedir(), ".hillclimb", "git-traces");
+var DEFAULT_STATE_DIR2 = path16.join(os9.homedir(), ".hillclimb", "git-traces");
 var LOCK_RETRIES2 = 120;
 var LOCK_RETRY_DELAY_MS2 = 500;
-var DEFAULT_LIVE_OWNER_MAX_WAIT_MS = 10 * 60 * 1e3;
+var DEFAULT_LIVE_OWNER_MAX_WAIT_MS2 = 10 * 60 * 1e3;
 var STALE_LOCK_TTL_MS3 = 60 * 60 * 1e3;
 var LockContentionError = class extends Error {
   constructor(lockPath, options) {
@@ -15650,25 +15922,25 @@ var LockContentionError = class extends Error {
 };
 function liveOwnerMaxWaitMs() {
   const raw = process.env.HILLCLIMB_GIT_TRACES_LOCK_LIVE_OWNER_MAX_WAIT_MS;
-  if (!raw) return DEFAULT_LIVE_OWNER_MAX_WAIT_MS;
+  if (!raw) return DEFAULT_LIVE_OWNER_MAX_WAIT_MS2;
   const parsed = Number(raw);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_LIVE_OWNER_MAX_WAIT_MS;
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_LIVE_OWNER_MAX_WAIT_MS2;
 }
 function stateDir3() {
   return process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? DEFAULT_STATE_DIR2;
 }
 function stateFileForRepo(repoRoot, tool, sessionId) {
   const hash = crypto6.createHash("sha256").update(
-    sessionId ? `${path15.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path15.resolve(repoRoot)}\0${tool}`
+    sessionId ? `${path16.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path16.resolve(repoRoot)}\0${tool}`
   ).digest("hex").slice(0, 16);
-  return path15.join(stateDir3(), `${hash}.json`);
+  return path16.join(stateDir3(), `${hash}.json`);
 }
 function lockFileForRepo(repoRoot, tool, sessionId) {
   return `${stateFileForRepo(repoRoot, tool, sessionId)}.lock`;
 }
 async function readStateFile(file) {
   try {
-    const raw = await fs15.promises.readFile(file, "utf-8");
+    const raw = await fs16.promises.readFile(file, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION3) {
       return null;
@@ -15682,7 +15954,7 @@ async function readStoredStateFile(file) {
   const state = await readStateFile(file);
   if (!state) return null;
   try {
-    return { state, mtimeMs: (await fs15.promises.stat(file)).mtimeMs };
+    return { state, mtimeMs: (await fs16.promises.stat(file)).mtimeMs };
   } catch {
     return null;
   }
@@ -15690,26 +15962,26 @@ async function readStoredStateFile(file) {
 async function listScopedSessionStates(repoRoot, tool) {
   let entries;
   try {
-    entries = await fs15.promises.readdir(stateDir3(), { withFileTypes: true });
+    entries = await fs16.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(stateDir3(), 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 fs15.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs16.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -15720,26 +15992,26 @@ async function listScopedSessionStates(repoRoot, tool) {
 async function listSessionStatesForSession(tool, sessionId) {
   let entries;
   try {
-    entries = await fs15.promises.readdir(stateDir3(), { withFileTypes: true });
+    entries = await fs16.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(stateDir3(), 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 fs15.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs16.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -15780,17 +16052,17 @@ async function writeLegacySessionState(state, tool) {
   await writeStateFile(stateFileForRepo(state.repoRoot, tool), state);
 }
 async function writeStateFile(file, state) {
-  await fs15.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
+  await fs16.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   const tmp = `${file}.tmp`;
-  await fs15.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+  await fs16.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
     mode: 384
   });
-  await fs15.promises.rename(tmp, file);
+  await fs16.promises.rename(tmp, file);
 }
 async function touchSessionState(repoRoot, tool, sessionId) {
   const now = /* @__PURE__ */ new Date();
   try {
-    await fs15.promises.utimes(
+    await fs16.promises.utimes(
       stateFileForRepo(repoRoot, tool, sessionId),
       now,
       now
@@ -15800,7 +16072,7 @@ async function touchSessionState(repoRoot, tool, sessionId) {
 }
 async function statSessionStateMtime(repoRoot, tool, sessionId) {
   try {
-    const stat = await fs15.promises.stat(
+    const stat = await fs16.promises.stat(
       stateFileForRepo(repoRoot, tool, sessionId)
     );
     return stat.mtimeMs;
@@ -15810,7 +16082,7 @@ async function statSessionStateMtime(repoRoot, tool, sessionId) {
 }
 async function deleteStateFile(file) {
   try {
-    await fs15.promises.unlink(file);
+    await fs16.promises.unlink(file);
   } catch {
   }
 }
@@ -15849,7 +16121,7 @@ async function acquireLock3(repoRoot, tool, sessionId, retries, delayMs, options
 }
 async function acquireLockWithoutTiming(repoRoot, tool, sessionId, retries, delayMs, options = {}) {
   const lockPath = lockFileForRepo(repoRoot, tool, sessionId);
-  await fs15.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
+  await fs16.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   const bounded = retries !== void 0 || delayMs !== void 0;
   const attempts = retries ?? LOCK_RETRIES2;
   const delay = delayMs ?? LOCK_RETRY_DELAY_MS2;
@@ -15859,9 +16131,9 @@ async function acquireLockWithoutTiming(repoRoot, tool, sessionId, retries, dela
   let extensionLogged = false;
   for (let i = 0; ; i++) {
     try {
-      const fd = await fs15.promises.open(
+      const fd = await fs16.promises.open(
         lockPath,
-        fs15.constants.O_CREAT | fs15.constants.O_EXCL | fs15.constants.O_WRONLY
+        fs16.constants.O_CREAT | fs16.constants.O_EXCL | fs16.constants.O_WRONLY
       );
       await fd.write(String(process.pid));
       await fd.close();
@@ -15870,7 +16142,7 @@ async function acquireLockWithoutTiming(repoRoot, tool, sessionId, retries, dela
       if (err.code !== "EEXIST") throw err;
       let regularLockFile = false;
       try {
-        regularLockFile = (await fs15.promises.lstat(lockPath)).isFile();
+        regularLockFile = (await fs16.promises.lstat(lockPath)).isFile();
       } catch (statErr) {
         if (statErr.code === "ENOENT") {
           i--;
@@ -15921,21 +16193,21 @@ async function acquireLockWithoutTiming(repoRoot, tool, sessionId, retries, dela
 }
 async function releaseLock3(repoRoot, tool, sessionId) {
   try {
-    await fs15.promises.unlink(lockFileForRepo(repoRoot, tool, sessionId));
+    await fs16.promises.unlink(lockFileForRepo(repoRoot, tool, sessionId));
   } catch {
   }
 }
 async function sweepStaleLockFiles(ttlMs = STALE_LOCK_TTL_MS3, now = Date.now()) {
   let entries;
   try {
-    entries = await fs15.promises.readdir(stateDir3(), { withFileTypes: true });
+    entries = await fs16.promises.readdir(stateDir3(), { withFileTypes: true });
   } catch {
     return 0;
   }
   let removed = 0;
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".lock")) continue;
-    const file = path15.join(stateDir3(), entry.name);
+    const file = path16.join(stateDir3(), entry.name);
     if (await reapLockIfStale(file, {
       maxAgeMs: ttlMs,
       now
@@ -15947,7 +16219,6 @@ async function sweepStaleLockFiles(ttlMs = STALE_LOCK_TTL_MS3, now = Date.now())
 }
 
 // src/git-traces/handlers.ts
-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;
@@ -15965,12 +16236,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 resolveHookCwd(payload);
@@ -16023,7 +16294,8 @@ async function uploadFile(client, contributionId, filename, mimeType, buffer) {
   await client.uploadToPresignedUrl(
     presigned.presignedUrl,
     presigned.headers,
-    buffer
+    buffer,
+    { contributionId, uploadId: presigned.upload.id }
   );
   appendLog(
     "info",
@@ -16158,7 +16430,7 @@ function freezeEpochBaseline(params) {
       sessionId,
       tool,
       baselineSha,
-      CLI_VERSION2,
+      CLI_VERSION,
       epoch,
       prevHeadSha,
       transitionKind,
@@ -16249,7 +16521,7 @@ function buildEpochBaselineArtifacts(params) {
       sessionId,
       tool,
       baselineSha,
-      CLI_VERSION2,
+      CLI_VERSION,
       epoch,
       prevHeadSha,
       transitionKind,
@@ -16998,7 +17270,7 @@ async function recoverFromWedgedDiff(params) {
       state.sessionId,
       tool,
       currentSha,
-      CLI_VERSION2,
+      CLI_VERSION,
       state.epoch,
       null,
       "initial",
@@ -17275,7 +17547,8 @@ async function processStopRepo(repo, tool, sessionId, recordedAt, lineageCheck,
           });
           return outcome === "uploaded" ? await finishSuccessfulStop("uploaded") : outcome;
         }
-        if (!artifacts2 || !canUploadEpochBaselineArtifacts(1, artifacts2)) {
+        if (!artifacts2) return "failed";
+        if (!canUploadEpochBaselineArtifacts(1, artifacts2)) {
           return "skipped";
         }
         const registered = await registerInitialContribution({
@@ -17469,7 +17742,8 @@ async function processStopRepo(repo, tool, sessionId, recordedAt, lineageCheck,
           missingObjectRecovery(state, "stop-diff")
         );
       }
-      if (!artifacts || !canUploadEpochBaselineArtifacts(1, artifacts)) {
+      if (!artifacts) return "failed";
+      if (!canUploadEpochBaselineArtifacts(1, artifacts)) {
         return "skipped";
       }
       const registered = await registerInitialContribution({
@@ -17586,7 +17860,7 @@ async function collectStopTargets(tool, sessionId, repos, repoByRoot) {
   let needsLineageCheck = false;
   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(
@@ -17618,7 +17892,7 @@ async function lateInitSkipReason(payload, tool) {
   const transcriptPath = payload.transcript_path;
   if (!transcriptPath) return tool === "codex" ? null : "no-transcript-path";
   try {
-    const stat = await fs16.promises.stat(path16.resolve(transcriptPath));
+    const stat = await fs17.promises.stat(path17.resolve(transcriptPath));
     return stat.isFile() ? null : "transcript-not-a-file";
   } catch {
     return "transcript-missing";
@@ -17735,9 +18009,9 @@ async function handleSessionEnd(payload, tool) {
   if (sessionId) {
     const states = await listSessionStatesForSession(tool, sessionId);
     for (const { state } of states) {
-      const repoRoot = path16.resolve(state.repoRoot);
+      const repoRoot = path17.resolve(state.repoRoot);
       repoRoots.add(repoRoot);
-      const canProcess = repoByRoot.has(repoRoot) || project && path16.resolve(project.repoRoot) === repoRoot;
+      const canProcess = repoByRoot.has(repoRoot) || project && path17.resolve(project.repoRoot) === repoRoot;
       if (canProcess && tool === "codex" && state.codexLineageChecked !== true) {
         needsLineageCheck = true;
       }
@@ -17771,7 +18045,7 @@ async function handleSessionEnd(payload, tool) {
   let skipped = 0;
   let failed = 0;
   for (const repoRoot of repoRoots) {
-    const repo = repoByRoot.get(path16.resolve(repoRoot)) ?? (project && path16.resolve(project.repoRoot) === path16.resolve(repoRoot) ? { repoRoot: project.repoRoot, config: project.config } : null);
+    const repo = repoByRoot.get(path17.resolve(repoRoot)) ?? (project && path17.resolve(project.repoRoot) === path17.resolve(repoRoot) ? { repoRoot: project.repoRoot, config: project.config } : null);
     if (!repo) {
       skipped++;
       appendLog(
@@ -18033,7 +18307,7 @@ async function runGitTracesWorker() {
   const tool = process.env[TOOL_ENV_FLAG2] ?? parseToolArg2(process.argv.slice(2)) ?? null;
   appendLog(
     "info",
-    `git-traces worker started (pid ${process.pid}, tool=${tool ?? "<none>"})`
+    `git-traces worker started (pid ${process.pid}, tool=${tool ?? "<none>"}, cliVersion=${CLI_VERSION})`
   );
   if (!tool || !KNOWN_TOOLS.has(tool)) {
     appendLog(
@@ -18118,29 +18392,29 @@ ${stack}` : ""}`
 }
 
 // src/outputs/zip.ts
-import fs18 from "fs";
-import path18 from "path";
+import fs19 from "fs";
+import path19 from "path";
 import archiver2 from "archiver";
 
 // src/outputs/downloads.ts
 import { execSync as execSync2 } from "child_process";
-import fs17 from "fs";
-import os9 from "os";
-import path17 from "path";
+import fs18 from "fs";
+import os10 from "os";
+import path18 from "path";
 function getDownloadsFolder() {
-  const home = os9.homedir();
+  const home = os10.homedir();
   if (process.platform === "linux") {
     try {
       const xdgDir = execSync2("xdg-user-dir DOWNLOAD", {
         encoding: "utf-8",
         timeout: 3e3
       }).trim();
-      if (xdgDir && fs17.existsSync(xdgDir)) return xdgDir;
+      if (xdgDir && fs18.existsSync(xdgDir)) return xdgDir;
     } catch {
     }
   }
-  const downloads = path17.join(home, "Downloads");
-  if (fs17.existsSync(downloads)) return downloads;
+  const downloads = path18.join(home, "Downloads");
+  if (fs18.existsSync(downloads)) return downloads;
   return home;
 }
 
@@ -18149,11 +18423,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 (!fs18.existsSync(candidate)) return candidate;
+  let candidate = path19.join(dir, `${base}${ext}`);
+  if (!fs19.existsSync(candidate)) return candidate;
   let i = 1;
-  while (fs18.existsSync(candidate)) {
-    candidate = path18.join(dir, `${base}-${i}${ext}`);
+  while (fs19.existsSync(candidate)) {
+    candidate = path19.join(dir, `${base}-${i}${ext}`);
     i++;
   }
   return candidate;
@@ -18163,13 +18437,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 = fs18.createWriteStream(outputPath);
+    const output = fs19.createWriteStream(outputPath);
     const archive = archiver2("zip", { zlib: { level: 6 } });
     const done = new Promise((resolve, reject) => {
       output.on("close", resolve);
@@ -18363,15 +18637,15 @@ async function confirmExport(group, output) {
 }
 
 // src/sources/claude.ts
-import fs19 from "fs";
-import os10 from "os";
-import path19 from "path";
+import fs20 from "fs";
+import os11 from "os";
+import path20 from "path";
 import readline2 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 fs19.promises.readFile(indexPath, "utf-8");
+    const raw = await fs20.promises.readFile(indexPath, "utf-8");
     const data = JSON.parse(raw);
     if (data.originalPath && typeof data.originalPath === "string") {
       return data.originalPath;
@@ -18379,12 +18653,12 @@ async function resolveRepoPath(projectDir) {
   } catch {
   }
   const cwdCounts = /* @__PURE__ */ new Map();
-  const entries = await fs19.promises.readdir(projectDir, {
+  const entries = await fs20.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);
     }
@@ -18403,7 +18677,7 @@ async function resolveRepoPath(projectDir) {
   return null;
 }
 async function extractCwdFromJsonl(filePath) {
-  const stream = fs19.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs20.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -18425,12 +18699,12 @@ async function extractCwdFromJsonl(filePath) {
 async function collectFiles(dir, baseDir, sourceName, repoPath, results) {
   let entries;
   try {
-    entries = await fs19.promises.readdir(dir, { withFileTypes: true });
+    entries = await fs20.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);
@@ -18452,19 +18726,19 @@ function fallbackDecode(encodedName) {
 var ClaudeSource = class {
   name = "claude";
   async scan() {
-    const baseDir = path19.join(os10.homedir(), ".claude", "projects");
+    const baseDir = path20.join(os11.homedir(), ".claude", "projects");
     try {
-      await fs19.promises.access(baseDir);
+      await fs20.promises.access(baseDir);
     } catch {
       return [];
     }
-    const projectDirs = await fs19.promises.readdir(baseDir, {
+    const projectDirs = await fs20.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(
@@ -18482,12 +18756,12 @@ var ClaudeSource = class {
 };
 
 // src/sources/codex.ts
-import fs20 from "fs";
-import os11 from "os";
-import path20 from "path";
+import fs21 from "fs";
+import os12 from "os";
+import path21 from "path";
 import readline3 from "readline";
 async function parseSessionMeta2(filePath) {
-  const stream = fs20.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs21.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline3.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -18512,12 +18786,12 @@ async function findJsonlFiles(dir) {
   async function walk(d) {
     let entries;
     try {
-      entries = await fs20.promises.readdir(d, { withFileTypes: true });
+      entries = await fs21.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")) {
@@ -18531,11 +18805,11 @@ async function findJsonlFiles(dir) {
 async function loadHistory(historyPath) {
   const map = /* @__PURE__ */ new Map();
   try {
-    await fs20.promises.access(historyPath);
+    await fs21.promises.access(historyPath);
   } catch {
     return map;
   }
-  const stream = fs20.createReadStream(historyPath, { encoding: "utf-8" });
+  const stream = fs21.createReadStream(historyPath, { encoding: "utf-8" });
   const rl = readline3.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -18562,14 +18836,14 @@ async function loadHistory(historyPath) {
 var CodexSource = class {
   name = "codex";
   async scan() {
-    const codexDir = path20.join(os11.homedir(), ".codex");
-    const sessionsDir2 = path20.join(codexDir, "sessions");
+    const codexDir = path21.join(os12.homedir(), ".codex");
+    const sessionsDir2 = path21.join(codexDir, "sessions");
     try {
-      await fs20.promises.access(sessionsDir2);
+      await fs21.promises.access(sessionsDir2);
     } catch {
       return [];
     }
-    const historyPath = path20.join(codexDir, "history.jsonl");
+    const historyPath = path21.join(codexDir, "history.jsonl");
     const [jsonlFiles, historyMap] = await Promise.all([
       findJsonlFiles(sessionsDir2),
       loadHistory(historyPath)
@@ -18592,8 +18866,8 @@ var CodexSource = class {
       });
       const historyLines = historyMap.get(meta.sessionId);
       if (historyLines) {
-        const sessionDir = path20.relative(sessionsDir2, path20.dirname(filePath));
-        const historyAbsPath = path20.join(
+        const sessionDir = path21.relative(sessionsDir2, path21.dirname(filePath));
+        const historyAbsPath = path21.join(
           sessionsDir2,
           sessionDir,
           `history-${meta.sessionId}.jsonl`
@@ -18613,18 +18887,18 @@ var CodexSource = class {
 };
 
 // src/sources/copilotChat.ts
-import fs21 from "fs";
-import os12 from "os";
-import path21 from "path";
+import fs22 from "fs";
+import os13 from "os";
+import path22 from "path";
 import { fileURLToPath } from "url";
 function vsCodeUserDirs() {
-  const home = os12.homedir();
+  const home = os13.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;
 }
@@ -18639,7 +18913,7 @@ function uriToFsPath(uri) {
 async function readWorkspaceFolder(workspaceJsonPath) {
   let raw;
   try {
-    raw = await fs21.promises.readFile(workspaceJsonPath, "utf-8");
+    raw = await fs22.promises.readFile(workspaceJsonPath, "utf-8");
   } catch {
     return null;
   }
@@ -18661,10 +18935,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 fs21.promises.readdir(workspaceStorage, {
+        hashDirs = await fs22.promises.readdir(workspaceStorage, {
           withFileTypes: true
         });
       } catch {
@@ -18672,22 +18946,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 fs21.promises.readdir(transcriptsDir, {
+          transcriptEntries = await fs22.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) {
@@ -18695,7 +18969,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 }
           });
@@ -18735,7 +19009,7 @@ function reportRedactionStats(noun, stats) {
 async function filterByTimeRange(group, range) {
   const results = await Promise.all(
     group.files.map(
-      (f) => fs22.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
+      (f) => fs23.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
     )
   );
   const filtered = [];
@@ -18762,10 +19036,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}.`);
@@ -18796,7 +19070,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,