hillclimb 0.6.2 → 0.7.0

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs19 from "fs";
-import path24 from "path";
+import fs21 from "fs";
+import path23 from "path";
 import * as p6 from "@clack/prompts";
 
 // src/commands/init.ts
@@ -252,6 +252,95 @@ function appendLog(level, message) {
   }
 }
 
+// src/platform/put.ts
+import fs4 from "fs";
+import http from "http";
+import https from "https";
+var DEFAULT_SOCKET_IDLE_TIMEOUT_MS = 12e4;
+var DEFAULT_DEADLINE_MS = 60 * 6e4;
+var MAX_RESPONSE_BODY_BYTES = 64 * 1024;
+async function putToPresignedUrl(url, headers, body, options) {
+  const socketIdleTimeoutMs = options?.socketIdleTimeoutMs ?? DEFAULT_SOCKET_IDLE_TIMEOUT_MS;
+  const deadlineMs = options?.deadlineMs ?? DEFAULT_DEADLINE_MS;
+  const parsed = new URL(url);
+  const transport = parsed.protocol === "http:" ? http : https;
+  const contentLength = body.kind === "buffer" ? body.buffer.byteLength : body.sizeBytes;
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const settleResolve = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadlineTimer);
+      resolve(result);
+    };
+    const settleReject = (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadlineTimer);
+      reject(err);
+    };
+    const req = transport.request(
+      parsed,
+      {
+        method: "PUT",
+        // One-shot upload; skip the keep-alive agent pool so the idle
+        // timeout below dies with this socket instead of leaking onto a
+        // reused one.
+        agent: false,
+        headers: { ...headers, "content-length": String(contentLength) }
+      },
+      (res) => {
+        const chunks = [];
+        let buffered = 0;
+        res.on("data", (chunk) => {
+          if (buffered >= MAX_RESPONSE_BODY_BYTES) return;
+          const remaining = MAX_RESPONSE_BODY_BYTES - buffered;
+          chunks.push(
+            chunk.length > remaining ? chunk.subarray(0, remaining) : chunk
+          );
+          buffered += Math.min(chunk.length, remaining);
+        });
+        res.on("end", () => {
+          const status = res.statusCode ?? 0;
+          settleResolve({
+            status,
+            ok: status >= 200 && status < 300,
+            bodyText: Buffer.concat(chunks).toString("utf8")
+          });
+        });
+        res.on("error", settleReject);
+      }
+    );
+    const deadlineTimer = setTimeout(() => {
+      const err = new Error(
+        `PUT to presigned URL exceeded ${deadlineMs}ms deadline (elapsed ${Date.now() - start}ms)`
+      );
+      settleReject(err);
+      req.destroy(err);
+    }, deadlineMs);
+    deadlineTimer.unref();
+    req.setTimeout(socketIdleTimeoutMs, () => {
+      const err = new Error(
+        `PUT to presigned URL timed out: socket idle for ${socketIdleTimeoutMs}ms (elapsed ${Date.now() - start}ms)`
+      );
+      settleReject(err);
+      req.destroy(err);
+    });
+    req.on("error", settleReject);
+    if (body.kind === "buffer") {
+      req.end(body.buffer);
+    } else {
+      const stream = fs4.createReadStream(body.path);
+      stream.on("error", (err) => {
+        settleReject(err);
+        req.destroy(err);
+      });
+      stream.pipe(req);
+    }
+  });
+}
+
 // src/platform/client.ts
 var PlatformError = class extends Error {
   constructor(message, status, code) {
@@ -457,8 +546,21 @@ var PlatformClient = class {
     );
   }
   async uploadToPresignedUrl(presignedUrl, headers, body) {
-    const ab = new ArrayBuffer(body.byteLength);
-    new Uint8Array(ab).set(body);
+    await this.putToPresignedUrlLogged(presignedUrl, headers, {
+      kind: "buffer",
+      buffer: body
+    });
+  }
+  // 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 putToPresignedUrlLogged(presignedUrl, headers, body) {
     const host = (() => {
       try {
         return new URL(presignedUrl).host;
@@ -466,14 +568,11 @@ var PlatformClient = class {
         return "presigned-url";
       }
     })();
+    const sizeBytes = body.kind === "buffer" ? body.buffer.byteLength : body.sizeBytes;
     const start = Date.now();
     let res;
     try {
-      res = await fetch(presignedUrl, {
-        method: "PUT",
-        headers,
-        body: new Blob([ab])
-      });
+      res = await putToPresignedUrl(presignedUrl, headers, body);
     } catch (err) {
       appendLog(
         "error",
@@ -484,11 +583,7 @@ var PlatformClient = class {
     const elapsedMs = Date.now() - start;
     if (!res.ok) {
       appendLog("warn", `[PUT ${host}] ${res.status} ${elapsedMs}ms`);
-      let detail = "";
-      try {
-        detail = await res.text();
-      } catch {
-      }
+      const detail = res.bodyText;
       throw new PlatformError(
         `PUT to presigned URL failed: HTTP ${res.status}${detail ? ` ${detail}` : ""}`,
         res.status
@@ -496,7 +591,7 @@ var PlatformClient = class {
     }
     appendLog(
       "info",
-      `[PUT ${host}] ${res.status} ${elapsedMs}ms (${body.byteLength} bytes)`
+      `[PUT ${host}] ${res.status} ${elapsedMs}ms (${sizeBytes} bytes)`
     );
   }
   async submitContribution(contributionId) {
@@ -523,12 +618,12 @@ var PlatformClient = class {
 
 // src/platform/hooks.ts
 import { execFileSync } from "child_process";
-import fs5 from "fs";
+import fs6 from "fs";
 import os2 from "os";
 import path6 from "path";
 
 // src/gitignore.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import path5 from "path";
 function toGitignorePattern(repoRoot, file) {
   const rel = path5.relative(repoRoot, file);
@@ -548,7 +643,7 @@ async function ensureGitignored(repoRoot, files) {
   let content = "";
   let created = false;
   try {
-    content = await fs4.promises.readFile(gitignorePath, "utf-8");
+    content = await fs5.promises.readFile(gitignorePath, "utf-8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
     created = true;
@@ -567,7 +662,7 @@ async function ensureGitignored(repoRoot, files) {
   if (next) next += "\n";
   next += ["# Hillclimb hook files", ...added].join("\n");
   next += "\n";
-  await fs4.promises.writeFile(gitignorePath, next);
+  await fs5.promises.writeFile(gitignorePath, next);
   return {
     path: gitignorePath,
     added,
@@ -684,7 +779,7 @@ var TOOLS = [
 ];
 function isDir(p7) {
   try {
-    return fs5.statSync(p7).isDirectory();
+    return fs6.statSync(p7).isDirectory();
   } catch {
     return false;
   }
@@ -710,7 +805,7 @@ function settingsPath(repoRoot, def) {
 }
 async function readJson(file, options = {}) {
   try {
-    const raw = await fs5.promises.readFile(file, "utf-8");
+    const raw = await fs6.promises.readFile(file, "utf-8");
     if (!raw.trim()) return {};
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
@@ -720,8 +815,8 @@ async function readJson(file, options = {}) {
     if (options.repairMalformed && err instanceof SyntaxError) {
       const backup = `${file}.malformed-${Date.now()}`;
       try {
-        const raw = await fs5.promises.readFile(file, "utf-8");
-        await fs5.promises.writeFile(backup, raw);
+        const raw = await fs6.promises.readFile(file, "utf-8");
+        await fs6.promises.writeFile(backup, raw);
         appendLog(
           "warn",
           `hooks: backed up malformed JSON hook file ${file} to ${backup}`
@@ -739,8 +834,8 @@ async function readJson(file, options = {}) {
   }
 }
 async function writeJson(file, obj) {
-  await fs5.promises.mkdir(path6.dirname(file), { recursive: true });
-  await fs5.promises.writeFile(file, `${JSON.stringify(obj, null, 2)}
+  await fs6.promises.mkdir(path6.dirname(file), { recursive: true });
+  await fs6.promises.writeFile(file, `${JSON.stringify(obj, null, 2)}
 `);
 }
 function claudeHookPresent(matchers, command, options = {}) {
@@ -1084,19 +1179,19 @@ export default HillclimbPlugin;
 `;
 async function opencodeInstall(file, content = OPENCODE_PLUGIN_CONTENT) {
   try {
-    const existing = await fs5.promises.readFile(file, "utf-8");
+    const existing = await fs6.promises.readFile(file, "utf-8");
     if (existing === content) {
       return { installed: 0, alreadyPresent: 1 };
     }
   } catch {
   }
-  await fs5.promises.mkdir(path6.dirname(file), { recursive: true });
-  await fs5.promises.writeFile(file, content);
+  await fs6.promises.mkdir(path6.dirname(file), { recursive: true });
+  await fs6.promises.writeFile(file, content);
   return { installed: 1, alreadyPresent: 0 };
 }
 async function opencodeCheck(file) {
   try {
-    const content = await fs5.promises.readFile(file, "utf-8");
+    const content = await fs6.promises.readFile(file, "utf-8");
     return content.includes(OPENCODE_PLUGIN_MARKER);
   } catch {
     return false;
@@ -1395,7 +1490,7 @@ function codexHooksEnabledInConfig(content) {
 }
 async function areCodexHooksEnabled() {
   try {
-    const content = await fs5.promises.readFile(codexConfigPath(), "utf-8");
+    const content = await fs6.promises.readFile(codexConfigPath(), "utf-8");
     return codexHooksEnabledInConfig(content);
   } catch {
     return false;
@@ -1405,13 +1500,13 @@ async function ensureCodexHooksEnabled() {
   let content;
   const configPath2 = codexConfigPath();
   try {
-    content = await fs5.promises.readFile(configPath2, "utf-8");
+    content = await fs6.promises.readFile(configPath2, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
-      await fs5.promises.mkdir(path6.dirname(configPath2), {
+      await fs6.promises.mkdir(path6.dirname(configPath2), {
         recursive: true
       });
-      await fs5.promises.writeFile(configPath2, "[features]\nhooks = true\n");
+      await fs6.promises.writeFile(configPath2, "[features]\nhooks = true\n");
       return true;
     }
     throw err;
@@ -1449,7 +1544,7 @@ hooks = true
 `;
   }
   if (content === original) return false;
-  await fs5.promises.writeFile(configPath2, content);
+  await fs6.promises.writeFile(configPath2, content);
   return true;
 }
 var CLAUDE_DEF = TOOLS[0];
@@ -2187,15 +2282,15 @@ async function runStatus(args = []) {
 
 // src/commands/upload.ts
 import { spawn as spawn2 } from "child_process";
-import crypto3 from "crypto";
-import fs11 from "fs";
+import crypto4 from "crypto";
+import fs13 from "fs";
 import os6 from "os";
-import path15 from "path";
+import path14 from "path";
 import readline from "readline";
 
 // src/debug-logs.ts
 import crypto from "crypto";
-import fs9 from "fs";
+import fs10 from "fs";
 import path12 from "path";
 
 // src/hook-events.ts
@@ -2255,11 +2350,11 @@ import os3 from "os";
 import { Worker } from "worker_threads";
 
 // src/middleware/file-utils.ts
-import fs6 from "fs";
+import fs7 from "fs";
 async function checkBinary(filePath) {
   let handle = null;
   try {
-    handle = await fs6.promises.open(filePath, "r");
+    handle = await fs7.promises.open(filePath, "r");
     const buf = Buffer.alloc(8192);
     const { bytesRead } = await handle.read(buf, 0, 8192, 0);
     for (let i = 0; i < bytesRead; i++) {
@@ -2284,7 +2379,7 @@ async function readFileContent(file) {
     return { kind: "binary" };
   }
   try {
-    const content = await fs6.promises.readFile(file.absolutePath, "utf-8");
+    const content = await fs7.promises.readFile(file.absolutePath, "utf-8");
     return { kind: "text", content };
   } catch {
     return { kind: "error" };
@@ -10890,7 +10985,7 @@ var RedactMiddleware = class {
 var middleware = [];
 
 // src/middleware/secrets.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path9 from "path";
 var KNOWN_NON_SECRETS = /* @__PURE__ */ new Set([
   "true",
@@ -10971,7 +11066,7 @@ async function parseEnvFile(filePath) {
   const values = [];
   let content;
   try {
-    content = await fs7.promises.readFile(filePath, "utf-8");
+    content = await fs8.promises.readFile(filePath, "utf-8");
   } catch {
     return values;
   }
@@ -11039,7 +11134,7 @@ function addWithVariants(set, value) {
 async function discoverEnvFiles(repoRoot) {
   let entries;
   try {
-    entries = await fs7.promises.readdir(repoRoot);
+    entries = await fs8.promises.readdir(repoRoot);
   } catch {
     return [];
   }
@@ -11048,7 +11143,7 @@ async function discoverEnvFiles(repoRoot) {
     if (!name.startsWith(".env")) continue;
     const filePath = path9.join(repoRoot, name);
     try {
-      const stat = await fs7.promises.stat(filePath);
+      const stat = await fs8.promises.stat(filePath);
       if (stat.isFile()) envFiles.push(name);
     } catch {
     }
@@ -11115,12 +11210,15 @@ function getSourceBaseDir(sourceName) {
       return home;
   }
 }
+function archivePathFor(file) {
+  const baseDir = getSourceBaseDir(file.sourceName);
+  const relativePath = file.absolutePath.startsWith(baseDir) ? path10.relative(baseDir, file.absolutePath) : path10.basename(file.absolutePath);
+  return path10.join(file.sourceName, relativePath);
+}
 function addGroupToArchive(archive, group, selectedSources) {
   for (const file of group.files) {
     if (!selectedSources.has(file.sourceName)) continue;
-    const baseDir = getSourceBaseDir(file.sourceName);
-    const relativePath = file.absolutePath.startsWith(baseDir) ? path10.relative(baseDir, file.absolutePath) : path10.basename(file.absolutePath);
-    const archivePath = path10.join(file.sourceName, relativePath);
+    const archivePath = archivePathFor(file);
     if (file.content) {
       archive.append(file.content, { name: archivePath });
     } else {
@@ -11130,6 +11228,17 @@ function addGroupToArchive(archive, group, selectedSources) {
 }
 
 // src/outputs/platform.ts
+var UploadTooLargeError = class extends Error {
+  constructor(filename, sizeBytes, maxBytes) {
+    super(
+      `upload ${filename} is ${sizeBytes} bytes, over the ${maxBytes}-byte limit`
+    );
+    this.filename = filename;
+    this.sizeBytes = sizeBytes;
+    this.maxBytes = maxBytes;
+    this.name = "UploadTooLargeError";
+  }
+};
 async function buildZipBuffer(group, selectedSources) {
   const archive = archiver("zip", { zlib: { level: 6 } });
   const stream = new PassThrough();
@@ -11164,8 +11273,16 @@ var PlatformUploadOutput = class {
       zipFilename,
       autoSubmit,
       existingContributionId,
-      onContributionCreated
+      onContributionCreated,
+      maxUploadBytes
     } = this.opts;
+    if (maxUploadBytes !== void 0 && buffer.byteLength > maxUploadBytes) {
+      throw new UploadTooLargeError(
+        zipFilename,
+        buffer.byteLength,
+        maxUploadBytes
+      );
+    }
     let contributionId;
     if (existingContributionId) {
       contributionId = existingContributionId;
@@ -11195,15 +11312,26 @@ var PlatformUploadOutput = class {
     appendLog("info", `PUT to presigned URL succeeded for ${zipFilename}`);
     if (autoSubmit) {
       appendLog("info", `submitting contribution ${contributionId}`);
-      await client.submitContribution(contributionId);
-      appendLog("info", `contribution ${contributionId} submitted`);
+      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;
   }
 };
 
 // src/pipeline.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path11 from "path";
 function canonicalizePath(p7) {
   let resolved = path11.resolve(p7);
@@ -11239,7 +11367,7 @@ async function mergeByRepo(files) {
   const groups = [];
   for (const [repoPath, groupFiles] of grouped) {
     const stats = await Promise.all(
-      groupFiles.map((f) => fs8.promises.stat(f.absolutePath).catch(() => null))
+      groupFiles.map((f) => fs9.promises.stat(f.absolutePath).catch(() => null))
     );
     let lastModified = /* @__PURE__ */ new Date(0);
     for (const stat of stats) {
@@ -11262,7 +11390,7 @@ async function preloadFiles(group) {
     group.files.map(async (file) => {
       if (file.content) return file;
       try {
-        const buf = await fs8.promises.readFile(file.absolutePath);
+        const buf = await fs9.promises.readFile(file.absolutePath);
         const checkLen = Math.min(buf.length, 8192);
         for (let i = 0; i < checkLen; i++) {
           if (buf[i] === 0) {
@@ -11353,7 +11481,7 @@ async function transcriptFingerprint(payload) {
   if (!transcriptPath) return {};
   const resolved = path12.resolve(transcriptPath);
   try {
-    const stat = await fs9.promises.stat(resolved);
+    const stat = await fs10.promises.stat(resolved);
     return {
       transcriptPath: resolved,
       transcriptMtimeMs: stat.mtimeMs,
@@ -11409,7 +11537,7 @@ async function eventContext(tool, payload) {
 }
 async function readState(eventId) {
   try {
-    const raw = await fs9.promises.readFile(stateFile(eventId), "utf-8");
+    const raw = await fs10.promises.readFile(stateFile(eventId), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION) return null;
     return parsed;
@@ -11418,21 +11546,21 @@ async function readState(eventId) {
   }
 }
 async function writeState(state) {
-  await fs9.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+  await fs10.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
   const file = stateFile(state.eventId);
   const tmp = `${file}.tmp`;
-  await fs9.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+  await fs10.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
     mode: 384
   });
-  await fs9.promises.rename(tmp, file);
+  await fs10.promises.rename(tmp, file);
 }
 async function acquireLock(eventId) {
-  await fs9.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+  await fs10.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
   for (let i = 0; i < LOCK_RETRIES; i++) {
     try {
-      const fd = await fs9.promises.open(
+      const fd = await fs10.promises.open(
         lockFile(eventId),
-        fs9.constants.O_CREAT | fs9.constants.O_EXCL | fs9.constants.O_WRONLY
+        fs10.constants.O_CREAT | fs10.constants.O_EXCL | fs10.constants.O_WRONLY
       );
       await fd.write(String(process.pid));
       await fd.close();
@@ -11448,7 +11576,7 @@ async function acquireLock(eventId) {
 }
 async function releaseLock(eventId) {
   try {
-    await fs9.promises.unlink(lockFile(eventId));
+    await fs10.promises.unlink(lockFile(eventId));
   } catch {
   }
 }
@@ -11539,7 +11667,7 @@ async function uploadDebugLog(ctx, state) {
   const logPath = todayLogPath();
   let content;
   try {
-    content = await fs9.promises.readFile(logPath);
+    content = await fs10.promises.readFile(logPath);
   } catch (err) {
     appendLog(
       "warn",
@@ -11663,1832 +11791,281 @@ async function recordDebugLogCompletion(args) {
   }
 }
 
-// src/normalizer/index.ts
-import path13 from "path";
-
-// src/normalizer/claude.ts
-function stringify(value) {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
+// src/transcript-artifacts.ts
+import { gzipSync } from "zlib";
+var TRANSCRIPT_PATCH_FORMAT = "jsonl-append-v1";
+function epochPrefix(epoch) {
+  return `epoch-${String(epoch).padStart(3, "0")}`;
 }
-function extractTextReasoningToolUses(content) {
-  if (typeof content === "string") {
-    return [content.trim(), void 0, []];
-  }
-  const textParts = [];
-  const reasoningParts = [];
-  const toolBlocks = [];
-  if (Array.isArray(content)) {
-    for (const block of content) {
-      if (typeof block !== "object" || block === null) {
-        textParts.push(stringify(block));
-        continue;
-      }
-      const b = block;
-      const blockType = b.type;
-      if (blockType === "tool_use") {
-        toolBlocks.push(b);
-        continue;
-      }
-      if (blockType === "thinking" || blockType === "reasoning" || blockType === "analysis") {
-        const textValue2 = b.text !== void 0 && b.text !== null ? b.text : b.thinking;
-        if (typeof textValue2 === "string") {
-          reasoningParts.push(textValue2.trim());
-        } else {
-          reasoningParts.push(stringify(textValue2));
-        }
-        continue;
-      }
-      if (blockType === "code" && typeof b.code === "string") {
-        textParts.push(b.code);
-        continue;
-      }
-      const textValue = b.text;
-      if (typeof textValue === "string") {
-        textParts.push(textValue);
-      } else {
-        textParts.push(stringify(b));
-      }
-    }
-  } else if (content !== void 0 && content !== null) {
-    textParts.push(stringify(content));
-  }
-  const text2 = textParts.filter((p7) => p7 && p7.trim()).map((p7) => p7.trim()).join("\n\n");
-  const reasoning = reasoningParts.filter((p7) => p7 && p7.trim()).map((p7) => p7.trim()).join("\n\n");
-  return [text2, reasoning || void 0, toolBlocks];
-}
-function buildMetrics(usage) {
-  if (typeof usage !== "object" || usage === null) return void 0;
-  const u = usage;
-  const cachedTokens = u.cache_read_input_tokens || 0;
-  const creation = u.cache_creation_input_tokens || 0;
-  const inputTokens = u.input_tokens || 0;
-  const promptTokens = inputTokens + cachedTokens + creation;
-  const completionTokens = u.output_tokens || 0;
-  const extra = {};
-  for (const [key, value] of Object.entries(u)) {
-    if (key === "input_tokens" || key === "output_tokens") continue;
-    extra[key] = value;
-  }
-  return {
-    prompt_tokens: promptTokens,
-    completion_tokens: completionTokens,
-    cached_tokens: cachedTokens,
-    extra: Object.keys(extra).length > 0 ? extra : void 0
+function turnSuffix(turn) {
+  return `turn-${String(turn).padStart(3, "0")}`;
+}
+function snapshotFilename(epoch, recordedAt) {
+  return `${epochPrefix(epoch)}-snapshot-${recordedAt}.zip`;
+}
+function metaFilename(epoch, recordedAt) {
+  return `${epochPrefix(epoch)}-meta-${recordedAt}.json`;
+}
+function patchFilename(epoch, turn, recordedAt) {
+  return `${epochPrefix(epoch)}-${turnSuffix(turn)}-${recordedAt}.patch.gz`;
+}
+function buildEpochMeta(params) {
+  const meta = {
+    formatVersion: 1,
+    patchFormat: TRANSCRIPT_PATCH_FORMAT,
+    sessionId: params.sessionId,
+    tool: params.tool,
+    cliVersion: params.cliVersion,
+    epoch: params.epoch,
+    transitionKind: params.transitionKind,
+    baseline: params.baseline,
+    snapshotFilename: params.snapshotFilename,
+    transcriptArchivePath: params.transcriptArchivePath,
+    rawByteOffset: params.cursor.rawByteOffset,
+    rawPrefixSha256: params.cursor.rawPrefixSha256,
+    recordedAt: new Date(params.recordedAt).toISOString()
   };
+  return Buffer.from(JSON.stringify(meta, null, 2));
 }
-function formatToolResult(block, toolUseResult) {
-  const parts = [];
-  const content = block.content;
-  if (typeof content === "string") {
-    if (content.trim()) parts.push(content.trim());
-  } else if (Array.isArray(content)) {
-    for (const item of content) {
-      const text2 = stringify(item);
-      if (text2.trim()) parts.push(text2.trim());
-    }
-  } else if (content !== void 0 && content !== null && content !== "") {
-    parts.push(stringify(content));
-  }
-  let metadata;
-  if (toolUseResult && typeof toolUseResult === "object") {
-    metadata = { tool_use_result: toolUseResult };
-    const stdout = toolUseResult.stdout;
-    const stderr = toolUseResult.stderr;
-    const exitCode = toolUseResult.exitCode ?? toolUseResult.exit_code;
-    const interrupted = toolUseResult.interrupted;
-    const isImage = toolUseResult.isImage;
-    const formatted = [];
-    if (stdout) formatted.push(`[stdout]
-${stdout}`.trimEnd());
-    if (stderr) formatted.push(`[stderr]
-${stderr}`.trimEnd());
-    if (exitCode !== void 0 && exitCode !== null && exitCode !== 0)
-      formatted.push(`[exit_code] ${exitCode}`);
-    if (interrupted) formatted.push(`[interrupted] ${interrupted}`);
-    if (isImage) formatted.push(`[is_image] ${isImage}`);
-    const skipKeys = /* @__PURE__ */ new Set([
-      "stdout",
-      "stderr",
-      "exitCode",
-      "exit_code",
-      "interrupted",
-      "isImage"
-    ]);
-    const remainingMeta = {};
-    for (const [k, v] of Object.entries(toolUseResult)) {
-      if (!skipKeys.has(k)) remainingMeta[k] = v;
-    }
-    if (Object.keys(remainingMeta).length > 0) {
-      formatted.push(`[metadata] ${JSON.stringify(remainingMeta)}`);
-    }
-    if (formatted.length > 0) {
-      parts.push(formatted.filter(Boolean).join("\n"));
-    }
-  }
-  if (block.is_error === true) {
-    parts.push("[error] tool reported failure");
-    metadata = metadata || {};
-    metadata.is_error = true;
-  }
-  if (metadata !== void 0) {
-    if (!("raw_tool_result" in metadata)) {
-      metadata.raw_tool_result = block;
-    }
-  }
-  const resultText = parts.filter(Boolean).join("\n\n").trim();
-  return [resultText || void 0, metadata];
+function gzipPatch(redactedTail) {
+  return gzipSync(redactedTail);
 }
-function convertClaudeToTrajectory(jsonlContent, sessionId) {
-  const rawEvents = [];
-  for (const line of jsonlContent.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      rawEvents.push(JSON.parse(trimmed));
-    } catch {
-    }
+async function uploadArtifact(client, contributionId, filename, mimeType, buffer, maxBytes) {
+  if (maxBytes !== void 0 && buffer.byteLength > maxBytes) {
+    throw new UploadTooLargeError(filename, buffer.byteLength, maxBytes);
   }
-  if (rawEvents.length === 0) return null;
-  const events = rawEvents.sort(
-    (a, b) => (a.timestamp ?? "").localeCompare(b.timestamp ?? "")
+  const presigned = await client.createUpload(contributionId, {
+    originalFilename: filename,
+    mimeType,
+    sizeBytes: buffer.byteLength
+  });
+  appendLog(
+    "info",
+    `uploading ${filename} (${buffer.byteLength} bytes) to presigned URL`
   );
-  if (events.length === 0) return null;
-  let sid = sessionId ?? "";
-  for (const event of events) {
-    if (typeof event.sessionId === "string") {
-      sid = event.sessionId;
-      break;
-    }
-  }
-  let agentVersion = "unknown";
-  for (const event of events) {
-    if (typeof event.version === "string" && event.version) {
-      agentVersion = event.version;
-      break;
-    }
-  }
-  const cwds = /* @__PURE__ */ new Set();
-  const gitBranches = /* @__PURE__ */ new Set();
-  const agentIds = /* @__PURE__ */ new Set();
-  for (const event of events) {
-    if (typeof event.cwd === "string" && event.cwd) cwds.add(event.cwd);
-    if (typeof event.gitBranch === "string" && event.gitBranch)
-      gitBranches.add(event.gitBranch);
-    if (typeof event.agentId === "string" && event.agentId)
-      agentIds.add(event.agentId);
-  }
-  const agentExtra = {};
-  if (cwds.size > 0) agentExtra.cwds = [...cwds];
-  if (gitBranches.size > 0) agentExtra.git_branches = [...gitBranches];
-  if (agentIds.size > 0) agentExtra.agent_ids = [...agentIds];
-  let defaultModelName;
-  for (const event of events) {
-    const msg = event.message;
-    if (typeof msg !== "object" || msg === null) continue;
-    const model = msg.model;
-    if (typeof model === "string" && model) {
-      defaultModelName = model;
-      break;
-    }
-  }
-  const lastUsageByMsgId = /* @__PURE__ */ new Map();
-  for (const ev of events) {
-    if (ev.type !== "assistant") continue;
-    const msg = ev.message;
-    if (typeof msg !== "object" || msg === null) continue;
-    const mid = msg.id;
-    const usage = msg.usage;
-    if (mid && usage !== void 0) {
-      lastUsageByMsgId.set(mid, usage);
-    }
-  }
-  const normalizedEvents = [];
-  const pendingCalls = /* @__PURE__ */ new Map();
-  const seenMessageIds = /* @__PURE__ */ new Set();
-  for (const event of events) {
-    const message = event.message;
-    if (typeof message !== "object" || message === null) continue;
-    const msg = message;
-    const eventType = event.type;
-    const timestamp = event.timestamp;
-    if (eventType === "assistant") {
-      const [text2, reasoning, toolBlocks] = extractTextReasoningToolUses(
-        msg.content
+  await client.uploadToPresignedUrl(
+    presigned.presignedUrl,
+    presigned.headers,
+    buffer
+  );
+  appendLog("info", `PUT to presigned URL succeeded for ${filename}`);
+}
+
+// src/transcript-cursor.ts
+import crypto2 from "crypto";
+import fs11 from "fs";
+function sha256OfBuffer(buffer) {
+  return crypto2.createHash("sha256").update(buffer).digest("hex");
+}
+async function hashPrefix(filePath, byteLength) {
+  const hash = crypto2.createHash("sha256");
+  if (byteLength === 0) return hash;
+  await new Promise((resolve, reject) => {
+    const stream = fs11.createReadStream(filePath, {
+      start: 0,
+      end: byteLength - 1
+    });
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve());
+  });
+  return hash;
+}
+async function readRange(filePath, start, end) {
+  const fd = await fs11.promises.open(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(end - start);
+    let filled = 0;
+    while (filled < buffer.length) {
+      const { bytesRead } = await fd.read(
+        buffer,
+        filled,
+        buffer.length - filled,
+        start + filled
       );
-      const msgId = msg.id;
-      let metrics;
-      if (msgId && seenMessageIds.has(msgId)) {
-        metrics = void 0;
-      } else {
-        const usage = msgId ? lastUsageByMsgId.get(msgId) ?? msg.usage : msg.usage;
-        metrics = buildMetrics(usage);
-        if (msgId) seenMessageIds.add(msgId);
-      }
-      const extra = {};
-      for (const key of ["stop_reason", "stop_sequence", "requestId"]) {
-        const value = msg[key];
-        if (value !== void 0 && value !== null) extra[key] = value;
-      }
-      if (event.id) extra.id = event.id;
-      if (event.agentId) extra.agent_id = event.agentId;
-      if (event.cwd) extra.cwd = extra.cwd ?? event.cwd;
-      if (event.userType && event.userType !== "external")
-        extra.user_type = event.userType;
-      extra.is_sidechain = event.isSidechain ?? false;
-      const modelName = msg.model || defaultModelName;
-      if (text2 || reasoning || toolBlocks.length === 0) {
-        normalizedEvents.push({
-          kind: "message",
-          timestamp,
-          role: msg.role ?? "assistant",
-          text: text2 || "",
-          reasoning: msg.role === "assistant" ? reasoning : void 0,
-          metrics,
-          extra: Object.keys(extra).length > 0 ? extra : void 0,
-          model_name: modelName
-        });
-        metrics = void 0;
-      }
-      for (let idx = 0; idx < toolBlocks.length; idx++) {
-        const toolBlock = toolBlocks[idx];
-        const callId = toolBlock.id ?? toolBlock.tool_use_id;
-        if (!callId) continue;
-        const rawArguments = toolBlock.input;
-        const args = typeof rawArguments === "object" && rawArguments !== null && !Array.isArray(rawArguments) ? rawArguments : { input: rawArguments };
-        const callExtra = { ...extra };
-        if (toolBlock.is_error !== void 0)
-          callExtra.tool_use_is_error = toolBlock.is_error;
-        if (toolBlock.name)
-          callExtra.tool_use_name = callExtra.tool_use_name ?? toolBlock.name;
-        pendingCalls.set(callId, {
-          kind: "tool_call",
-          timestamp,
-          call_id: callId,
-          tool_name: toolBlock.name ?? "",
-          arguments: args,
-          raw_arguments: rawArguments,
-          reasoning,
-          status: toolBlock.status,
-          message: void 0,
-          extra: Object.keys(callExtra).length > 0 ? callExtra : void 0,
-          metrics: idx === 0 && metrics !== void 0 ? metrics : void 0,
-          model_name: modelName
-        });
-        if (idx === 0 && metrics !== void 0) metrics = void 0;
-      }
-      continue;
-    }
-    if (eventType === "user") {
-      const content = msg.content;
-      if (typeof content === "string") {
-        const text2 = content.trim();
-        if (text2) {
-          normalizedEvents.push({
-            kind: "message",
-            timestamp,
-            role: "user",
-            text: text2,
-            extra: { is_sidechain: event.isSidechain ?? false }
-          });
-        }
-        continue;
-      }
-      if (Array.isArray(content)) {
-        const textParts = [];
-        for (const block of content) {
-          if (typeof block === "object" && block !== null && block.type === "tool_result") {
-            const b = block;
-            const callId = b.tool_use_id;
-            const [formattedOutput, resultMetadata] = formatToolResult(
-              b,
-              event.toolUseResult
-            );
-            let callInfo = callId ? pendingCalls.get(callId) : void 0;
-            if (callId) pendingCalls.delete(callId);
-            if (!callInfo) {
-              callInfo = {
-                kind: "tool_call",
-                timestamp,
-                call_id: callId ?? "",
-                tool_name: b.name ?? b.tool_name ?? "",
-                arguments: {},
-                raw_arguments: void 0,
-                reasoning: void 0,
-                status: void 0,
-                message: void 0,
-                extra: void 0,
-                metrics: void 0,
-                model_name: defaultModelName
-              };
-            }
-            const extraVal = callInfo.extra;
-            const callExtra = typeof extraVal === "object" && extraVal !== null ? { ...extraVal } : {};
-            if (resultMetadata)
-              callExtra.tool_result_metadata = callExtra.tool_result_metadata ?? resultMetadata;
-            if (b.is_error !== void 0)
-              callExtra.tool_result_is_error = callExtra.tool_result_is_error ?? b.is_error;
-            callInfo.extra = Object.keys(callExtra).length > 0 ? callExtra : void 0;
-            callInfo.output = formattedOutput;
-            callInfo.metadata = resultMetadata;
-            callInfo.timestamp = callInfo.timestamp ?? timestamp;
-            callInfo.model_name = callInfo.model_name ?? defaultModelName;
-            normalizedEvents.push(callInfo);
-            continue;
-          }
-          textParts.push(stringify(block));
-        }
-        const textMessage = textParts.filter((p7) => p7 && p7.trim()).map((p7) => p7.trim()).join("\n\n");
-        if (textMessage) {
-          normalizedEvents.push({
-            kind: "message",
-            timestamp,
-            role: "user",
-            text: textMessage
-          });
-        }
-        continue;
-      }
-      if (content !== void 0 && content !== null && content !== "") {
-        const text2 = stringify(content).trim();
-        if (text2) {
-          normalizedEvents.push({
-            kind: "message",
-            timestamp,
-            role: "user",
-            text: text2
-          });
-        }
-      }
-    }
-  }
-  for (const leftover of pendingCalls.values()) {
-    normalizedEvents.push(leftover);
-  }
-  const steps = [];
-  let stepId = 1;
-  for (const normEvent of normalizedEvents) {
-    const step = convertEventToStep(normEvent, stepId, defaultModelName);
-    if (!step) continue;
-    if (step.source === "agent" && !step.model_name && defaultModelName) {
-      step.model_name = defaultModelName;
-    }
-    steps.push(step);
-    stepId++;
-  }
-  if (steps.length === 0) return null;
-  const promptValues = steps.filter((s) => s.metrics?.prompt_tokens !== void 0).map((s) => s.metrics.prompt_tokens);
-  const completionValues = steps.filter((s) => s.metrics?.completion_tokens !== void 0).map((s) => s.metrics.completion_tokens);
-  const cachedValues = steps.filter((s) => s.metrics?.cached_tokens !== void 0).map((s) => s.metrics.cached_tokens);
-  const serviceTiers = /* @__PURE__ */ new Set();
-  let cacheCreationTotal = 0;
-  let cacheReadTotal = 0;
-  let cacheCreationSeen = false;
-  let cacheReadSeen = false;
-  for (const step of steps) {
-    if (!step.metrics?.extra) continue;
-    const tier = step.metrics.extra.service_tier;
-    if (typeof tier === "string") serviceTiers.add(tier);
-    const cacheCreation = step.metrics.extra.cache_creation_input_tokens;
-    if (typeof cacheCreation === "number") {
-      cacheCreationTotal += cacheCreation;
-      cacheCreationSeen = true;
+      if (bytesRead === 0) break;
+      filled += bytesRead;
     }
-    const cacheRead = step.metrics.extra.cache_read_input_tokens;
-    if (typeof cacheRead === "number") {
-      cacheReadTotal += cacheRead;
-      cacheReadSeen = true;
+    return buffer.subarray(0, filled);
+  } finally {
+    await fd.close();
+  }
+}
+async function evaluateTranscript(filePath, cursor) {
+  const stat = await fs11.promises.stat(filePath);
+  if (stat.size < cursor.rawByteOffset) return { kind: "truncate" };
+  const prefixHash = await 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 lastNewline = grown.lastIndexOf(10);
+  if (lastNewline === -1) return { kind: "unchanged" };
+  const tail = grown.subarray(0, lastNewline + 1);
+  return {
+    kind: "append",
+    tail,
+    nextCursor: {
+      rawByteOffset: cursor.rawByteOffset + tail.length,
+      rawPrefixSha256: continuation.update(tail).digest("hex")
     }
-  }
-  const finalExtra = {};
-  if (serviceTiers.size > 0)
-    finalExtra.service_tiers = [...serviceTiers].sort();
-  if (cacheCreationSeen)
-    finalExtra.total_cache_creation_input_tokens = cacheCreationTotal;
-  if (cacheReadSeen) finalExtra.total_cache_read_input_tokens = cacheReadTotal;
-  const finalMetrics = {
-    total_prompt_tokens: promptValues.length > 0 ? promptValues.reduce((a, b) => a + b, 0) : void 0,
-    total_completion_tokens: completionValues.length > 0 ? completionValues.reduce((a, b) => a + b, 0) : void 0,
-    total_cached_tokens: cachedValues.length > 0 ? cachedValues.reduce((a, b) => a + b, 0) : void 0,
-    total_steps: steps.length,
-    extra: Object.keys(finalExtra).length > 0 ? finalExtra : void 0
   };
+}
+function truncateAtLastNewline(buffer) {
+  const lastNewline = buffer.lastIndexOf(10);
+  if (lastNewline === -1) return null;
+  const covered = buffer.subarray(0, lastNewline + 1);
   return {
-    schema_version: "ATIF-v1.2",
-    session_id: sid,
-    agent: {
-      name: "claude-code",
-      version: agentVersion,
-      model_name: defaultModelName,
-      extra: Object.keys(agentExtra).length > 0 ? agentExtra : void 0
-    },
-    steps,
-    final_metrics: finalMetrics
+    covered,
+    cursor: {
+      rawByteOffset: covered.length,
+      rawPrefixSha256: sha256OfBuffer(covered)
+    }
   };
 }
-function convertEventToStep(event, stepId, defaultModelName) {
-  if (event.kind === "message") {
-    const role = event.role ?? "user";
-    let source;
-    if (role === "assistant") source = "agent";
-    else if (role === "user") source = "user";
-    else source = "system";
-    const step = {
-      step_id: stepId,
-      timestamp: event.timestamp,
-      source,
-      message: event.text ?? ""
-    };
-    if (source === "agent") {
-      if (event.reasoning) step.reasoning_content = event.reasoning;
-      if (event.model_name) step.model_name = event.model_name;
-      else if (defaultModelName) step.model_name = defaultModelName;
+async function cursorMatchesFile(filePath, cursor) {
+  try {
+    const stat = await fs11.promises.stat(filePath);
+    if (stat.size < cursor.rawByteOffset) return false;
+    const prefixHash = await 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");
+    try {
+      const byte = Buffer.alloc(1);
+      const { bytesRead } = await fd.read(byte, 0, 1, cursor.rawByteOffset - 1);
+      return bytesRead === 1 && byte[0] === 10;
+    } finally {
+      await fd.close();
     }
-    if (event.metrics) step.metrics = event.metrics;
-    if (event.extra) step.extra = event.extra;
-    return step;
-  }
-  if (event.kind === "tool_call") {
-    const callId = event.call_id;
-    const toolName = event.tool_name;
-    if (!callId || !toolName) return null;
-    const toolCall = {
-      tool_call_id: callId,
-      function_name: toolName,
-      arguments: event.arguments ?? {}
-    };
-    const observationResult = {
-      source_call_id: callId,
-      content: event.output
-    };
-    const observation = event.output !== void 0 ? { results: [observationResult] } : void 0;
-    const extra = { ...event.extra ?? {} };
-    if (event.metadata !== void 0)
-      extra.metadata = extra.metadata ?? event.metadata;
-    if (event.raw_arguments !== void 0)
-      extra.raw_arguments = extra.raw_arguments ?? event.raw_arguments;
-    if (event.status !== void 0) extra.status = extra.status ?? event.status;
-    const summaryParts = [toolName, callId].filter(Boolean);
-    const message = event.message || `Executed ${summaryParts.length > 0 ? summaryParts.join(" ") : "Tool call"}`;
-    const step = {
-      step_id: stepId,
-      timestamp: event.timestamp,
-      source: "agent",
-      message,
-      tool_calls: [toolCall],
-      observation
-    };
-    if (event.model_name) step.model_name = event.model_name;
-    if (event.reasoning) step.reasoning_content = event.reasoning;
-    if (event.metrics) step.metrics = event.metrics;
-    if (Object.keys(extra).length > 0) step.extra = extra;
-    return step;
+  } catch {
+    return false;
   }
-  return null;
 }
 
-// src/normalizer/codex.ts
-function extractMessageText(content) {
-  const parts = [];
-  for (const block of content) {
-    if (typeof block === "object" && block !== null) {
-      const text2 = block.text;
-      if (typeof text2 === "string") parts.push(text2);
-    }
-  }
-  return parts.join("");
+// src/upload-state.ts
+import crypto3 from "crypto";
+import fs12 from "fs";
+import os5 from "os";
+import path13 from "path";
+var CURRENT_SCHEMA_VERSION2 = 1;
+var DEFAULT_STATE_DIR = path13.join(
+  os5.homedir(),
+  ".hillclimb",
+  "agent-uploads"
+);
+var DEFAULT_LOCK_WAIT_MS = 5 * 60 * 1e3;
+var DEFAULT_LOCK_RETRY_DELAY_MS = 500;
+var DEFAULT_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
+var STALE_LOCK_TTL_MS = 60 * 60 * 1e3;
+function stateDir2() {
+  return process.env.HILLCLIMB_UPLOAD_STATE_DIR ?? DEFAULT_STATE_DIR;
 }
-function parseOutputBlob(raw) {
-  if (raw === void 0 || raw === null) return [void 0, void 0];
-  let parsed = raw;
-  if (typeof raw === "string") {
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      return [raw, void 0];
-    }
-  }
-  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-    const obj = parsed;
-    let output = obj.output;
-    if (output === void 0 && Object.keys(obj).length > 0) {
-      output = JSON.stringify(obj);
-    }
-    const metadata = obj.metadata;
-    return [
-      output ?? void 0,
-      typeof metadata === "object" && metadata !== null ? metadata : void 0
-    ];
-  }
-  return [String(parsed), void 0];
+function readPositiveEnvMs(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0) return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function stateTtlMs() {
+  return readPositiveEnvMs(
+    "HILLCLIMB_UPLOAD_STATE_TTL_MS",
+    DEFAULT_STATE_TTL_MS
+  );
 }
-function asObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+function lockRetryDelayMs() {
+  return Math.max(
+    1,
+    readPositiveEnvMs(
+      "HILLCLIMB_UPLOAD_LOCK_RETRY_DELAY_MS",
+      DEFAULT_LOCK_RETRY_DELAY_MS
+    )
+  );
 }
-function compactExtra(extra) {
-  const compacted = {};
-  for (const [key, value] of Object.entries(extra)) {
-    if (value !== void 0 && value !== null) compacted[key] = value;
-  }
-  return Object.keys(compacted).length > 0 ? compacted : void 0;
+function lockRetries() {
+  return Math.max(
+    1,
+    Math.ceil(
+      readPositiveEnvMs("HILLCLIMB_UPLOAD_LOCK_WAIT_MS", DEFAULT_LOCK_WAIT_MS) / lockRetryDelayMs()
+    )
+  );
+}
+function stateFileFor(repoRoot, tool, sessionId) {
+  const hash = crypto3.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`;
 }
-function parseJsonObject(raw) {
-  const obj = asObject(raw);
-  if (obj) return obj;
-  if (typeof raw !== "string") return void 0;
+async function readUploadState(repoRoot, tool, sessionId) {
   try {
-    return asObject(JSON.parse(raw));
+    const raw = await fs12.promises.readFile(
+      stateFileFor(repoRoot, tool, sessionId),
+      "utf-8"
+    );
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION2) return null;
+    return parsed;
   } catch {
-    return void 0;
+    return null;
   }
 }
-function subagentRefFromSpawnOutput(args, rawOutput) {
-  const output = parseJsonObject(rawOutput);
-  const sessionId = typeof output?.agent_id === "string" && output.agent_id || typeof output?.agent_path === "string" && output.agent_path || void 0;
-  if (!sessionId) return void 0;
-  const extra = compactExtra({
-    agent_role: typeof args?.agent_type === "string" && args.agent_type || typeof output?.agent_role === "string" && output.agent_role || void 0,
-    nickname: typeof output?.nickname === "string" && output.nickname || typeof output?.agent_nickname === "string" && output.agent_nickname || void 0
-  });
-  return {
-    session_id: sessionId,
-    extra
-  };
-}
-function codexTrajectoryExtra(metaPayload) {
-  const source = asObject(metaPayload.source);
-  const subagent = asObject(source?.subagent);
-  const threadSpawn = asObject(subagent?.thread_spawn);
-  const parentThreadId = typeof threadSpawn?.parent_thread_id === "string" ? threadSpawn.parent_thread_id : void 0;
-  const subagentExtra = threadSpawn ? compactExtra({
-    depth: threadSpawn.depth,
-    agent_path: threadSpawn.agent_path,
-    agent_nickname: threadSpawn.agent_nickname,
-    agent_role: threadSpawn.agent_role
-  }) : void 0;
-  return compactExtra({
-    thread_source: metaPayload.thread_source,
-    agent_nickname: metaPayload.agent_nickname,
-    agent_role: metaPayload.agent_role,
-    parent_session_id: parentThreadId,
-    parent_thread_id: parentThreadId,
-    subagent: subagentExtra
+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 fs12.promises.rename(tmp, file);
 }
-function convertCodexToTrajectory(jsonlContent, sessionId) {
-  const rawEvents = [];
-  for (const line of jsonlContent.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      rawEvents.push(JSON.parse(trimmed));
-    } catch {
-    }
-  }
-  if (rawEvents.length === 0) return null;
-  const sessionMeta = rawEvents.find((e) => e.type === "session_meta");
-  const metaPayload = sessionMeta?.payload ?? {};
-  const sid = sessionId ?? (typeof metaPayload.id === "string" ? metaPayload.id : "");
-  const agentVersion = metaPayload.cli_version ?? "unknown";
-  const agentExtra = {};
-  for (const key of ["originator", "cwd", "git", "instructions"]) {
-    const value = metaPayload[key];
-    if (value !== void 0 && value !== null) agentExtra[key] = value;
-  }
-  let defaultModelName;
-  for (const event of rawEvents) {
-    if (event.type === "turn_context") {
-      const model = event.payload?.model;
-      if (typeof model === "string") {
-        defaultModelName = model;
-        break;
-      }
-    }
-  }
-  const normalizedEvents = [];
-  const pendingCalls = /* @__PURE__ */ new Map();
-  let pendingReasoning;
-  for (const event of rawEvents) {
-    const etype = event.type;
-    const payload = event.payload ?? {};
-    const timestamp = event.timestamp;
-    if (etype !== "response_item") continue;
-    const payloadType = payload.type;
-    if (payloadType === "reasoning") {
-      const summary = payload.summary;
-      if (Array.isArray(summary) && summary.length > 0) {
-        pendingReasoning = summary.filter((item) => typeof item === "string").join("\n");
-      } else {
-        pendingReasoning = void 0;
-      }
-      continue;
-    }
-    if (payloadType === "message") {
-      const content = payload.content;
-      const text2 = Array.isArray(content) ? extractMessageText(content) : "";
-      normalizedEvents.push({
-        kind: "message",
-        timestamp,
-        role: payload.role ?? "user",
-        text: text2,
-        reasoning: payload.role === "assistant" ? pendingReasoning : void 0
-      });
-      pendingReasoning = void 0;
-      continue;
-    }
-    if (payloadType === "web_search_call") {
-      const action = payload.action ?? {};
-      const actionType = action.type ?? "";
-      const args = { action_type: actionType };
-      if ("query" in action) args.query = action.query;
-      if ("queries" in action) args.queries = action.queries;
-      if ("url" in action) args.url = action.url;
-      normalizedEvents.push({
-        kind: "tool_call",
-        timestamp,
-        call_id: "",
-        tool_name: "web_search_call",
-        arguments: args,
-        reasoning: pendingReasoning,
-        status: payload.status
-      });
-      pendingReasoning = void 0;
-      continue;
-    }
-    if (payloadType === "function_call" || payloadType === "custom_tool_call") {
-      const callId = payload.call_id;
-      if (!callId) continue;
-      const rawArgsKey = payloadType === "function_call" ? "arguments" : "input";
-      const rawArguments = payload[rawArgsKey];
-      let parsedArgs;
-      if (typeof rawArguments === "string") {
-        try {
-          parsedArgs = JSON.parse(rawArguments);
-        } catch {
-          parsedArgs = { input: rawArguments };
-        }
-      } else if (rawArguments === void 0 || rawArguments === null) {
-        parsedArgs = {};
-      } else if (typeof rawArguments === "object" && !Array.isArray(rawArguments)) {
-        parsedArgs = rawArguments;
-      } else {
-        parsedArgs = { value: rawArguments };
-      }
-      pendingCalls.set(callId, {
-        kind: "tool_call",
-        timestamp,
-        call_id: callId,
-        tool_name: payload.name ?? "",
-        arguments: parsedArgs,
-        raw_arguments: rawArguments,
-        reasoning: pendingReasoning,
-        status: payload.status
-      });
-      pendingReasoning = void 0;
-      continue;
-    }
-    if (payloadType === "function_call_output" || payloadType === "custom_tool_call_output") {
-      const callId = payload.call_id;
-      const [outputText, metadata] = parseOutputBlob(payload.output);
-      let callInfo = callId ? pendingCalls.get(callId) : void 0;
-      if (callId) pendingCalls.delete(callId);
-      if (!callInfo) {
-        callInfo = {
-          kind: "tool_call",
-          timestamp,
-          call_id: callId ?? "",
-          tool_name: payload.name ?? "",
-          arguments: {},
-          reasoning: pendingReasoning
-        };
-      }
-      callInfo.output = outputText;
-      callInfo.metadata = metadata;
-      callInfo.timestamp = callInfo.timestamp ?? timestamp;
-      if (callInfo.tool_name === "spawn_agent") {
-        const subagentRef = subagentRefFromSpawnOutput(
-          callInfo.arguments,
-          payload.output
-        );
-        if (subagentRef) callInfo.subagentRefs = [subagentRef];
-      }
-      normalizedEvents.push(callInfo);
-      pendingReasoning = void 0;
-    }
-  }
-  const steps = [];
-  let stepId = 1;
-  for (const normEvent of normalizedEvents) {
-    const step = convertEventToStep2(normEvent, stepId, defaultModelName);
-    if (!step) continue;
-    if (step.source === "agent" && !step.model_name && defaultModelName) {
-      step.model_name = defaultModelName;
-    }
-    steps.push(step);
-    stepId++;
-  }
-  if (steps.length === 0) return null;
-  let finalMetrics;
-  for (let i = rawEvents.length - 1; i >= 0; i--) {
-    const event = rawEvents[i];
-    if (event.type !== "event_msg") continue;
-    const payload = event.payload;
-    if (!payload || payload.type !== "token_count") continue;
-    const info = payload.info;
-    if (!info || typeof info !== "object") continue;
-    const totalUsage = info.total_token_usage;
-    if (!totalUsage || typeof totalUsage !== "object") continue;
-    const promptTokens = totalUsage.input_tokens;
-    const completionTokens = totalUsage.output_tokens;
-    const reasoningTokens = totalUsage.reasoning_output_tokens;
-    const cachedTokens = totalUsage.cached_input_tokens;
-    const overallTokens = totalUsage.total_tokens;
-    finalMetrics = {
-      total_prompt_tokens: promptTokens || void 0,
-      total_completion_tokens: completionTokens || void 0,
-      total_cached_tokens: cachedTokens || void 0,
-      total_cost_usd: info.total_cost ?? info.cost_usd ?? void 0,
-      total_steps: steps.length,
-      extra: {
-        reasoning_output_tokens: reasoningTokens,
-        total_tokens: overallTokens,
-        last_token_usage: info.last_token_usage
-      }
-    };
-    break;
-  }
-  return {
-    schema_version: "ATIF-v1.5",
-    session_id: sid,
-    agent: {
-      name: "codex",
-      version: agentVersion,
-      model_name: defaultModelName,
-      extra: Object.keys(agentExtra).length > 0 ? agentExtra : void 0
-    },
-    steps,
-    final_metrics: finalMetrics,
-    extra: codexTrajectoryExtra(metaPayload)
-  };
-}
-function convertEventToStep2(event, stepId, defaultModelName) {
-  if (event.kind === "message") {
-    const role = event.role ?? "user";
-    let source;
-    if (role === "assistant") source = "agent";
-    else if (role === "user") source = "user";
-    else source = "system";
-    const step = {
-      step_id: stepId,
-      timestamp: event.timestamp,
-      source,
-      message: event.text ?? ""
-    };
-    if (source === "agent") {
-      if (event.reasoning) step.reasoning_content = event.reasoning;
-      if (defaultModelName) step.model_name = defaultModelName;
-    }
-    if (event.extra) step.extra = event.extra;
-    return step;
-  }
-  if (event.kind === "tool_call") {
-    const callId = event.call_id ?? "";
-    const toolName = event.tool_name ?? "";
-    const toolCall = {
-      tool_call_id: callId,
-      function_name: toolName,
-      arguments: typeof event.arguments === "object" && event.arguments !== null ? event.arguments : { value: event.arguments }
-    };
-    let observation;
-    if (event.output !== void 0) {
-      const result = {
-        source_call_id: callId || void 0,
-        content: event.output,
-        subagent_trajectory_ref: event.subagentRefs
-      };
-      observation = { results: [result] };
-    }
-    const extra = {};
-    if (event.metadata) extra.tool_metadata = event.metadata;
-    if (event.raw_arguments !== void 0)
-      extra.raw_arguments = event.raw_arguments;
-    if (event.status) extra.status = event.status;
-    const summaryParts = [toolName, callId].filter(Boolean);
-    const message = event.message || `Executed ${summaryParts.length > 0 ? summaryParts.join(" ") : "Tool call"}`;
-    const step = {
-      step_id: stepId,
-      timestamp: event.timestamp,
-      source: "agent",
-      message,
-      tool_calls: [toolCall],
-      observation
-    };
-    if (defaultModelName) step.model_name = defaultModelName;
-    if (event.reasoning) step.reasoning_content = event.reasoning;
-    if (event.metrics) step.metrics = event.metrics;
-    if (Object.keys(extra).length > 0) step.extra = extra;
-    return step;
-  }
-  return null;
-}
-
-// src/normalizer/types.ts
-var ATIF_VERSION = "ATIF-v1.6";
-function excludeNone(obj) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (value === void 0 || value === null) continue;
-    if (Array.isArray(value)) {
-      result[key] = value.map(
-        (item) => typeof item === "object" && item !== null && !Array.isArray(item) ? excludeNone(item) : item
-      );
-    } else if (typeof value === "object" && !Array.isArray(value)) {
-      result[key] = excludeNone(value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-
-// src/normalizer/copilotChat.ts
-function asObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function asNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function compactExtra2(extra) {
-  const result = {};
-  for (const [key, value] of Object.entries(extra)) {
-    if (value !== void 0 && value !== null) result[key] = value;
-  }
-  return Object.keys(result).length > 0 ? result : void 0;
-}
-function parseJsonLines(content) {
-  const entries = [];
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const parsed = asObject2(JSON.parse(trimmed));
-      if (!parsed) continue;
-      entries.push({
-        type: typeof parsed.type === "string" ? parsed.type : void 0,
-        data: asObject2(parsed.data),
-        id: typeof parsed.id === "string" ? parsed.id : void 0,
-        timestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : void 0
-      });
-    } catch {
-    }
-  }
-  return entries;
-}
-function parseArguments(value) {
-  const obj = asObject2(value);
-  if (obj) return obj;
-  if (typeof value === "string") {
-    try {
-      const parsed = asObject2(JSON.parse(value));
-      if (parsed) return parsed;
-    } catch {
-      return value ? { input: value } : {};
-    }
-  }
-  return value === void 0 || value === null ? {} : { value };
-}
-function buildMetrics2(data) {
-  const inputTokens = asNumber(data.inputTokens) ?? 0;
-  const outputTokens = asNumber(data.outputTokens) ?? 0;
-  const cacheReadTokens = asNumber(data.cacheReadTokens) ?? 0;
-  const cacheWriteTokens = asNumber(data.cacheWriteTokens) ?? 0;
-  const cost = asNumber(data.cost);
-  if (!inputTokens && !outputTokens && !cacheReadTokens && !cacheWriteTokens && !cost) {
-    return void 0;
-  }
-  return {
-    prompt_tokens: inputTokens + cacheReadTokens || void 0,
-    completion_tokens: outputTokens || void 0,
-    cached_tokens: cacheReadTokens || void 0,
-    cost_usd: cost || void 0,
-    extra: compactExtra2({
-      cache_write_tokens: cacheWriteTokens || void 0,
-      duration_ms: data.duration,
-      initiator: data.initiator,
-      api_call_id: data.apiCallId,
-      provider_call_id: data.providerCallId,
-      parent_tool_call_id: data.parentToolCallId,
-      quota_snapshots: data.quotaSnapshots,
-      copilot_usage: data.copilotUsage
-    })
-  };
-}
-function finalMetricsFromSteps(steps) {
-  let prompt = 0;
-  let completion = 0;
-  let cached = 0;
-  let cost = 0;
-  for (const step of steps) {
-    prompt += step.metrics?.prompt_tokens ?? 0;
-    completion += step.metrics?.completion_tokens ?? 0;
-    cached += step.metrics?.cached_tokens ?? 0;
-    cost += step.metrics?.cost_usd ?? 0;
-  }
-  return {
-    total_prompt_tokens: prompt || void 0,
-    total_completion_tokens: completion || void 0,
-    total_cached_tokens: cached || void 0,
-    total_cost_usd: cost || void 0,
-    total_steps: steps.length
-  };
-}
-function makeToolCall(request) {
-  const req = asObject2(request);
-  if (!req) return null;
-  const callId = typeof req.toolCallId === "string" && req.toolCallId || typeof req.id === "string" && req.id || "";
-  const name = typeof req.name === "string" && req.name || typeof req.toolName === "string" && req.toolName || "tool";
-  return {
-    tool_call_id: callId,
-    function_name: name,
-    arguments: parseArguments(req.arguments)
-  };
-}
-function toolCallFromExecutionStart(data) {
-  const callId = typeof data.toolCallId === "string" && data.toolCallId || typeof data.id === "string" && data.id || "";
-  const name = typeof data.toolName === "string" && data.toolName || typeof data.name === "string" && data.name || "tool";
-  return {
-    tool_call_id: callId,
-    function_name: name,
-    arguments: parseArguments(data.arguments)
-  };
-}
-function contentFromToolResult(data) {
-  const result = asObject2(data.result);
-  if (typeof result?.content === "string") return result.content;
-  if (typeof data.content === "string") return data.content;
-  return void 0;
-}
-function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
-  const entries = parseJsonLines(jsonlContent);
-  if (entries.length === 0) return null;
-  let sid = sessionId ?? "unknown";
-  let copilotVersion = "unknown";
-  let vscodeVersion;
-  let cwd;
-  let defaultModelName;
-  const steps = [];
-  const pendingReasoning = [];
-  const pendingToolSteps = /* @__PURE__ */ new Map();
-  let lastAgentStep;
-  for (const entry of entries) {
-    const data = entry.data ?? {};
-    if (entry.type === "session.start") {
-      if (!sessionId && typeof data.sessionId === "string")
-        sid = data.sessionId;
-      if (typeof data.copilotVersion === "string")
-        copilotVersion = data.copilotVersion;
-      if (typeof data.vscodeVersion === "string")
-        vscodeVersion = data.vscodeVersion;
-      const context = asObject2(data.context);
-      if (typeof context?.cwd === "string") cwd = context.cwd;
-      continue;
-    }
-    if (entry.type === "user.message" || entry.type === "system.message") {
-      const content = typeof data.content === "string" && data.content || typeof data.transformedContent === "string" && data.transformedContent || "";
-      if (!content.trim()) continue;
-      const source = entry.type === "system.message" ? "system" : "user";
-      const step = {
-        step_id: steps.length + 1,
-        timestamp: entry.timestamp,
-        source,
-        message: content,
-        extra: compactExtra2({
-          attachments: data.attachments,
-          source: data.source,
-          agent_mode: data.agentMode,
-          interaction_id: data.interactionId
-        })
-      };
-      steps.push(step);
-      continue;
-    }
-    if (entry.type === "assistant.reasoning") {
-      if (typeof data.content === "string" && data.content.trim()) {
-        pendingReasoning.push(data.content.trim());
-      }
-      continue;
-    }
-    if (entry.type === "assistant.message") {
-      const toolCalls = (Array.isArray(data.toolRequests) ? data.toolRequests : []).flatMap((request) => {
-        const call = makeToolCall(request);
-        return call ? [call] : [];
-      });
-      const content = typeof data.content === "string" && data.content.trim() ? data.content.trim() : "";
-      const reasoning = typeof data.reasoningText === "string" && data.reasoningText.trim() || pendingReasoning.join("\n\n") || void 0;
-      pendingReasoning.length = 0;
-      const step = {
-        step_id: steps.length + 1,
-        timestamp: entry.timestamp,
-        source: "agent",
-        message: content || (toolCalls.length > 0 ? "(tool use)" : ""),
-        model_name: defaultModelName,
-        extra: compactExtra2({
-          message_id: data.messageId,
-          phase: data.phase,
-          output_tokens: data.outputTokens
-        })
-      };
-      if (reasoning) step.reasoning_content = reasoning;
-      if (toolCalls.length > 0) step.tool_calls = toolCalls;
-      if (step.message || step.tool_calls?.length || step.reasoning_content) {
-        steps.push(step);
-        lastAgentStep = step;
-        for (const call of toolCalls) {
-          if (call.tool_call_id) pendingToolSteps.set(call.tool_call_id, step);
-        }
-      }
-      continue;
-    }
-    if (entry.type === "tool.execution_start") {
-      const toolCall = toolCallFromExecutionStart(data);
-      const step = {
-        step_id: steps.length + 1,
-        timestamp: entry.timestamp,
-        source: "agent",
-        message: `Executed ${toolCall.function_name} ${toolCall.tool_call_id}`.trim(),
-        model_name: defaultModelName,
-        tool_calls: [toolCall]
-      };
-      steps.push(step);
-      lastAgentStep = step;
-      if (toolCall.tool_call_id)
-        pendingToolSteps.set(toolCall.tool_call_id, step);
-      continue;
-    }
-    if (entry.type === "tool.execution_complete") {
-      const callId = typeof data.toolCallId === "string" && data.toolCallId || typeof data.id === "string" && data.id || "";
-      const target = pendingToolSteps.get(callId);
-      const content = contentFromToolResult(data);
-      if (target && content !== void 0) {
-        const observation = target.observation ?? { results: [] };
-        observation.results.push({
-          source_call_id: callId || void 0,
-          content
-        });
-        target.observation = observation;
-        const extra = { ...target.extra ?? {} };
-        extra.tool_success = data.success;
-        target.extra = compactExtra2(extra);
-      }
-      if (callId) pendingToolSteps.delete(callId);
-      continue;
-    }
-    if (entry.type === "assistant.usage") {
-      if (typeof data.model === "string" && !defaultModelName) {
-        defaultModelName = data.model;
-        if (lastAgentStep && !lastAgentStep.model_name) {
-          lastAgentStep.model_name = defaultModelName;
-        }
-      }
-      const metrics = buildMetrics2(data);
-      if (metrics && lastAgentStep && !lastAgentStep.metrics) {
-        lastAgentStep.metrics = metrics;
-      }
-    }
-  }
-  if (steps.length === 0) return null;
-  return {
-    schema_version: ATIF_VERSION,
-    session_id: sid,
-    agent: {
-      name: "github-copilot-chat",
-      version: copilotVersion,
-      model_name: defaultModelName,
-      extra: compactExtra2({
-        vscode_version: vscodeVersion,
-        cwd
-      })
-    },
-    steps,
-    final_metrics: finalMetricsFromSteps(steps)
-  };
-}
-
-// src/normalizer/cursor.ts
-function convertCursorToTrajectory(jsonlContent, sessionId) {
-  const lines = [];
-  for (const line of jsonlContent.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      lines.push(JSON.parse(trimmed));
-    } catch {
-    }
-  }
-  if (lines.length === 0) return null;
-  const steps = [];
-  let stepId = 1;
-  for (const entry of lines) {
-    const role = entry.role;
-    if (!role) continue;
-    let source;
-    if (role === "assistant") source = "agent";
-    else if (role === "user") source = "user";
-    else source = "system";
-    const contentParts = entry.message?.content;
-    let text2 = "";
-    if (Array.isArray(contentParts)) {
-      const textParts = [];
-      for (const part of contentParts) {
-        if (typeof part === "object" && part !== null && typeof part.text === "string") {
-          textParts.push(part.text);
-        }
-      }
-      text2 = textParts.join("\n\n").trim();
-    }
-    if (!text2) continue;
-    const step = {
-      step_id: stepId,
-      source,
-      message: text2
-    };
-    steps.push(step);
-    stepId++;
-  }
-  if (steps.length === 0) return null;
-  const finalMetrics = {
-    total_steps: steps.length
-  };
-  return {
-    schema_version: "ATIF-v1.6",
-    session_id: sessionId ?? "unknown",
-    agent: {
-      name: "cursor",
-      version: "unknown"
-    },
-    steps,
-    final_metrics: finalMetrics
-  };
-}
-
-// src/normalizer/opencode.ts
-function asObject3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function asArray(value) {
-  return Array.isArray(value) ? value : [];
-}
-function asNumber2(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function compactExtra3(extra) {
-  const result = {};
-  for (const [key, value] of Object.entries(extra)) {
-    if (value !== void 0 && value !== null) result[key] = value;
-  }
-  return Object.keys(result).length > 0 ? result : void 0;
-}
-function parseJsonLines2(content) {
-  const events = [];
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const parsed = JSON.parse(trimmed);
-      const obj = asObject3(parsed);
-      if (obj) events.push(obj);
-    } catch {
-    }
-  }
-  return events;
-}
-function timestampToIso(value) {
-  const numeric = asNumber2(value);
-  if (numeric === void 0) return void 0;
-  const millis = numeric < 1e12 ? numeric * 1e3 : numeric;
-  const date = new Date(millis);
-  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
-}
-function timeFromObject(value) {
-  const obj = asObject3(value);
-  if (!obj) return void 0;
-  return timestampToIso(obj.start ?? obj.created ?? obj.completed ?? obj.end);
-}
-function stringify2(value) {
-  if (typeof value === "string") return value;
+async function deleteUploadState(repoRoot, tool, sessionId) {
   try {
-    return JSON.stringify(value);
+    await fs12.promises.unlink(stateFileFor(repoRoot, tool, sessionId));
   } catch {
-    return String(value);
-  }
-}
-function argsFromUnknown(value) {
-  const obj = asObject3(value);
-  if (obj) return obj;
-  if (typeof value === "string") {
-    try {
-      const parsed = JSON.parse(value);
-      const parsedObj = asObject3(parsed);
-      if (parsedObj) return parsedObj;
-    } catch {
-      return value ? { input: value } : {};
-    }
-  }
-  return value === void 0 || value === null ? {} : { value };
-}
-function modelNameFromInfo(info) {
-  const model = asObject3(info.model);
-  const modelID = typeof info.modelID === "string" && info.modelID || typeof model?.modelID === "string" && model.modelID || void 0;
-  const providerID = typeof info.providerID === "string" && info.providerID || typeof model?.providerID === "string" && model.providerID || void 0;
-  if (providerID && modelID) return `${providerID}/${modelID}`;
-  return modelID;
-}
-function metricsFromTokens(tokens, cost) {
-  const t = asObject3(tokens);
-  if (!t) return void 0;
-  const cache = asObject3(t.cache);
-  const input = asNumber2(t.input) ?? 0;
-  const output = asNumber2(t.output) ?? 0;
-  const reasoning = asNumber2(t.reasoning) ?? 0;
-  const cacheRead = asNumber2(cache?.read) ?? 0;
-  const cacheWrite = asNumber2(cache?.write) ?? 0;
-  const costUsd = asNumber2(cost);
-  if (!input && !output && !cacheRead && !cacheWrite && !costUsd) {
-    return void 0;
-  }
-  const extra = compactExtra3({
-    reasoning_tokens: reasoning || void 0,
-    cache_write_tokens: cacheWrite || void 0
-  });
-  return {
-    prompt_tokens: input + cacheRead || void 0,
-    completion_tokens: output || void 0,
-    cached_tokens: cacheRead || void 0,
-    cost_usd: costUsd || void 0,
-    extra
-  };
-}
-function metricsFromInfo(info) {
-  return metricsFromTokens(info.tokens, info.cost);
-}
-function addFinalMetricTotals(totals, metrics) {
-  if (!metrics) return;
-  totals.total_prompt_tokens += metrics.prompt_tokens ?? 0;
-  totals.total_completion_tokens += metrics.completion_tokens ?? 0;
-  totals.total_cached_tokens += metrics.cached_tokens ?? 0;
-  totals.total_cost_usd += metrics.cost_usd ?? 0;
-}
-function finalMetricsFromSteps2(steps) {
-  const totals = {
-    total_prompt_tokens: 0,
-    total_completion_tokens: 0,
-    total_cached_tokens: 0,
-    total_cost_usd: 0,
-    total_steps: steps.length,
-    extra: {}
-  };
-  for (const step of steps) addFinalMetricTotals(totals, step.metrics);
-  return {
-    total_prompt_tokens: totals.total_prompt_tokens || void 0,
-    total_completion_tokens: totals.total_completion_tokens || void 0,
-    total_cached_tokens: totals.total_cached_tokens || void 0,
-    total_cost_usd: totals.total_cost_usd || void 0,
-    total_steps: steps.length
-  };
-}
-function entryFromLine(line) {
-  const info = asObject3(line.info);
-  if (info) {
-    return {
-      info,
-      parts: asArray(line.parts).flatMap((part) => {
-        const obj = asObject3(part);
-        return obj ? [obj] : [];
-      })
-    };
-  }
-  if (typeof line.role === "string" || typeof line.sessionID === "string") {
-    return {
-      info: line,
-      parts: asArray(line.parts).flatMap((part) => {
-        const obj = asObject3(part);
-        return obj ? [obj] : [];
-      })
-    };
-  }
-  return null;
-}
-function entriesFromEventWrappers(lines) {
-  const byMessage = /* @__PURE__ */ new Map();
-  function getEntry(messageID, sessionID) {
-    let entry = byMessage.get(messageID);
-    if (!entry) {
-      entry = { info: { id: messageID, sessionID }, parts: [] };
-      byMessage.set(messageID, entry);
-    }
-    return entry;
-  }
-  for (const line of lines) {
-    const type = line.type;
-    const props = asObject3(line.properties) ?? line;
-    if (type === "message.updated") {
-      const info = asObject3(props.info);
-      const id = typeof info?.id === "string" ? info.id : void 0;
-      if (!info || !id) continue;
-      const entry = getEntry(id, info.sessionID);
-      entry.info = info;
-      continue;
-    }
-    if (type === "message.part.updated") {
-      const part = asObject3(props.part);
-      const messageID = typeof part?.messageID === "string" && part.messageID || void 0;
-      if (!part || !messageID) continue;
-      const entry = getEntry(messageID, part.sessionID);
-      const partID = typeof part.id === "string" ? part.id : void 0;
-      const existingIndex = partID ? entry.parts.findIndex((p7) => p7.id === partID) : -1;
-      if (existingIndex >= 0) entry.parts[existingIndex] = part;
-      else entry.parts.push(part);
-    }
-  }
-  return [...byMessage.values()];
-}
-function getSessionId(sessionId, exportInfo, entries) {
-  if (sessionId) return sessionId;
-  if (typeof exportInfo?.id === "string") return exportInfo.id;
-  for (const entry of entries) {
-    if (typeof entry.info.sessionID === "string") return entry.info.sessionID;
-  }
-  return "unknown";
-}
-function getAgentVersion(exportInfo) {
-  return typeof exportInfo?.version === "string" && exportInfo.version || "unknown";
-}
-function sortEntries(entries) {
-  return [...entries].sort((a, b) => {
-    const at = asNumber2(asObject3(a.info.time)?.created) ?? 0;
-    const bt = asNumber2(asObject3(b.info.time)?.created) ?? 0;
-    return at - bt;
-  });
-}
-function splitAssistantParts(parts) {
-  let sawBoundary = false;
-  const groups = [];
-  let current = [];
-  for (const part of parts) {
-    const type = part.type;
-    if (type === "step-start") {
-      sawBoundary = true;
-      if (current.length > 0) groups.push(current);
-      current = [part];
-      continue;
-    }
-    current.push(part);
-    if (type === "step-finish") {
-      sawBoundary = true;
-      groups.push(current);
-      current = [];
-    }
-  }
-  if (current.length > 0) groups.push(current);
-  return sawBoundary ? groups : [parts];
-}
-function textFromFilePart(part) {
-  const filename = typeof part.filename === "string" ? part.filename : void 0;
-  const url = typeof part.url === "string" ? part.url : void 0;
-  const mime = typeof part.mime === "string" ? part.mime : void 0;
-  const label = filename ?? url;
-  if (!label) return void 0;
-  return mime ? `[file:${mime}] ${label}` : `[file] ${label}`;
-}
-function buildUserStep(entry, stepId, defaultModelName) {
-  const textParts = [];
-  const extra = {};
-  for (const part of entry.parts) {
-    if (part.type === "text" && typeof part.text === "string") {
-      if (part.text.trim()) textParts.push(part.text.trim());
-      continue;
-    }
-    if (part.type === "file") {
-      const fileText = textFromFilePart(part);
-      if (fileText) textParts.push(fileText);
-    }
-  }
-  const message = textParts.join("\n\n").trim();
-  if (!message) return null;
-  if (entry.info.agent) extra.agent = entry.info.agent;
-  if (entry.info.tools) extra.tools = entry.info.tools;
-  return {
-    step_id: stepId,
-    timestamp: timeFromObject(entry.info.time),
-    source: "user",
-    message,
-    model_name: defaultModelName,
-    extra: compactExtra3(extra)
-  };
-}
-function buildAgentStep(parts, info, stepId, defaultModelName, fallbackMetrics) {
-  const textParts = [];
-  const reasoningParts = [];
-  const toolCalls = [];
-  const observationResults = [];
-  const extra = {};
-  let metrics;
-  let timestamp = timeFromObject(info.time);
-  for (const part of parts) {
-    if (!timestamp) timestamp = timeFromObject(part.time);
-    switch (part.type) {
-      case "text":
-        if (typeof part.text === "string" && part.text.trim()) {
-          textParts.push(part.text.trim());
-        }
-        break;
-      case "reasoning":
-        if (typeof part.text === "string" && part.text.trim()) {
-          reasoningParts.push(part.text.trim());
-        }
-        break;
-      case "file": {
-        const fileText = textFromFilePart(part);
-        if (fileText) textParts.push(fileText);
-        break;
-      }
-      case "tool": {
-        const state = asObject3(part.state) ?? {};
-        const callID = typeof part.callID === "string" && part.callID || typeof part.id === "string" && part.id || "";
-        const toolName = typeof part.tool === "string" && part.tool || "tool";
-        const input = argsFromUnknown(state.input);
-        toolCalls.push({
-          tool_call_id: callID,
-          function_name: toolName,
-          arguments: input
-        });
-        const output = state.output ?? state.error;
-        if (output !== void 0 && output !== null) {
-          observationResults.push({
-            source_call_id: callID || void 0,
-            content: stringify2(output)
-          });
-        }
-        if (state.status) extra.status = state.status;
-        if (state.metadata) extra.tool_metadata = state.metadata;
-        if (part.metadata) extra.part_metadata = part.metadata;
-        break;
-      }
-      case "step-finish":
-        metrics = metricsFromTokens(part.tokens, part.cost) ?? metrics;
-        if (part.reason) extra.finish_reason = part.reason;
-        if (part.snapshot) extra.snapshot = part.snapshot;
-        break;
-      case "patch":
-        extra.patches = [...asArray(extra.patches), part];
-        break;
-      case "agent":
-        if (part.name) extra.agent = part.name;
-        break;
-      case "retry":
-        extra.retry = part;
-        break;
-    }
-  }
-  metrics = metrics ?? fallbackMetrics;
-  if (textParts.length === 0 && reasoningParts.length === 0 && toolCalls.length === 0 && !metrics) {
-    return null;
-  }
-  const observation = observationResults.length > 0 ? { results: observationResults } : void 0;
-  const step = {
-    step_id: stepId,
-    timestamp,
-    source: "agent",
-    message: textParts.length > 0 ? textParts.join("\n\n") : "(tool use)",
-    model_name: modelNameFromInfo(info) ?? defaultModelName
-  };
-  if (reasoningParts.length > 0)
-    step.reasoning_content = reasoningParts.join("\n\n");
-  if (toolCalls.length > 0) step.tool_calls = toolCalls;
-  if (observation) step.observation = observation;
-  if (metrics) step.metrics = metrics;
-  const compactedExtra = compactExtra3(extra);
-  if (compactedExtra) step.extra = compactedExtra;
-  return step;
-}
-function buildUnavailableAgentStep(info, stepId, defaultModelName) {
-  const metrics = metricsFromInfo(info);
-  if (!metrics && !modelNameFromInfo(info) && !info.error && !info.finish) {
-    return null;
-  }
-  return {
-    step_id: stepId,
-    timestamp: timeFromObject(info.time),
-    source: "agent",
-    message: "(message unavailable)",
-    model_name: modelNameFromInfo(info) ?? defaultModelName,
-    metrics,
-    extra: compactExtra3({
-      content_unavailable: true,
-      finish_reason: info.finish,
-      error: info.error
-    })
-  };
-}
-function convertMessageEntriesToTrajectory(entries, sessionId, exportInfo) {
-  if (entries.length === 0) return null;
-  const orderedEntries = sortEntries(entries);
-  const defaultModelName = orderedEntries.map((entry) => modelNameFromInfo(entry.info)).find((model) => typeof model === "string");
-  const steps = [];
-  for (const entry of orderedEntries) {
-    const role = entry.info.role;
-    if (role === "user") {
-      const step = buildUserStep(entry, steps.length + 1, defaultModelName);
-      if (step) steps.push(step);
-      continue;
-    }
-    if (role !== "assistant") continue;
-    if (entry.parts.length === 0) {
-      const step = buildUnavailableAgentStep(
-        entry.info,
-        steps.length + 1,
-        defaultModelName
-      );
-      if (step) steps.push(step);
-      continue;
-    }
-    const groups = splitAssistantParts(entry.parts);
-    const hasPartMetrics = groups.some(
-      (group) => group.some((part) => part.type === "step-finish")
-    );
-    const fallbackMetrics = hasPartMetrics ? void 0 : metricsFromInfo(entry.info);
-    for (let i = 0; i < groups.length; i++) {
-      const step = buildAgentStep(
-        groups[i],
-        entry.info,
-        steps.length + 1,
-        defaultModelName,
-        i === 0 ? fallbackMetrics : void 0
-      );
-      if (step) steps.push(step);
-    }
   }
-  if (steps.length === 0) return null;
-  return {
-    schema_version: ATIF_VERSION,
-    session_id: getSessionId(sessionId, exportInfo, orderedEntries),
-    agent: {
-      name: "opencode",
-      version: getAgentVersion(exportInfo),
-      model_name: defaultModelName
-    },
-    steps,
-    final_metrics: finalMetricsFromSteps2(steps)
-  };
-}
-function convertRunEventsToTrajectory(events, sessionId) {
-  const session = sessionId ?? (events.map((event) => event.sessionID).find((sid) => typeof sid === "string") || "unknown");
-  const turns = [];
-  let current = null;
-  for (const event of events) {
-    const type = event.type;
-    if (type === "step_start") {
-      current = { parts: [], timestamp: event.timestamp };
-      continue;
-    }
-    if (type === "step_finish") {
-      if (current) {
-        current.finish = asObject3(event.part) ?? {};
-        turns.push(current);
-        current = null;
-      }
-      continue;
-    }
-    if (current && (type === "text" || type === "reasoning" || type === "tool_use")) {
-      const part = asObject3(event.part);
-      if (part) current.parts.push(part);
-    }
-  }
-  const steps = [];
-  for (const turn of turns) {
-    const parts = [...turn.parts];
-    if (turn.finish) {
-      parts.push({ ...turn.finish, type: "step-finish" });
-    }
-    const step = buildAgentStep(
-      parts,
-      { time: { created: turn.timestamp } },
-      steps.length + 1,
-      void 0
-    );
-    if (step) steps.push(step);
-  }
-  if (steps.length === 0) return null;
-  return {
-    schema_version: ATIF_VERSION,
-    session_id: session,
-    agent: {
-      name: "opencode",
-      version: "unknown"
-    },
-    steps,
-    final_metrics: finalMetricsFromSteps2(steps)
-  };
-}
-function isRunEvent(lines) {
-  return lines.some(
-    (line) => ["step_start", "step_finish", "text", "reasoning", "tool_use"].includes(
-      String(line.type ?? "")
-    )
-  );
-}
-function convertOpenCodeToTrajectory(content, sessionId) {
-  const trimmed = content.trim();
-  if (!trimmed) return null;
   try {
-    const parsed = JSON.parse(trimmed);
-    const parsedObj = asObject3(parsed);
-    const messages = asArray(parsedObj?.messages);
-    if (parsedObj && messages.length > 0) {
-      const entries2 = messages.flatMap((message) => {
-        const entry = entryFromLine(asObject3(message) ?? {});
-        return entry ? [entry] : [];
-      });
-      return convertMessageEntriesToTrajectory(
-        entries2,
-        sessionId,
-        asObject3(parsedObj.info)
-      );
-    }
+    await fs12.promises.unlink(cursorFileFor(repoRoot, tool, sessionId));
   } catch {
   }
-  const lines = parseJsonLines2(content);
-  if (lines.length === 0) return null;
-  if (isRunEvent(lines)) return convertRunEventsToTrajectory(lines, sessionId);
-  const wrappedEntries = entriesFromEventWrappers(lines);
-  const entries = wrappedEntries.length > 0 ? wrappedEntries : lines.flatMap((line) => {
-    const entry = entryFromLine(line);
-    return entry ? [entry] : [];
-  });
-  return convertMessageEntriesToTrajectory(entries, sessionId);
-}
-
-// src/normalizer/index.ts
-function normalizeContent(sourceName, content, sessionId) {
-  switch (sourceName) {
-    case "claude":
-      return convertClaudeToTrajectory(content, sessionId);
-    case "codex":
-      return convertCodexToTrajectory(content, sessionId);
-    case "cursor":
-      return convertCursorToTrajectory(content, sessionId);
-    case "opencode":
-      return convertOpenCodeToTrajectory(content, sessionId);
-    case "copilot-chat":
-      return convertCopilotChatToTrajectory(content, sessionId);
-    default:
-      return null;
-  }
 }
-var NormalizeMiddleware = class {
-  name = "normalize";
-  async process(group) {
-    const newFiles = [];
-    for (const file of group.files) {
-      newFiles.push(file);
-      if (!file.absolutePath.endsWith(".jsonl")) continue;
-      if (!["claude", "codex", "cursor", "opencode", "copilot-chat"].includes(
-        file.sourceName
-      ))
-        continue;
-      const sessionId = file.metadata?.sessionId ?? (file.sourceName === "codex" ? void 0 : path13.basename(file.absolutePath, ".jsonl"));
-      try {
-        const content = file.content ? file.content.toString("utf-8") : null;
-        if (!content) continue;
-        const trajectory = normalizeContent(
-          file.sourceName,
-          content,
-          sessionId
-        );
-        if (!trajectory) {
-          appendLog(
-            "warn",
-            `normalize: produced no ATIF for source=${file.sourceName} session=${sessionId ?? "<unknown>"} file=${file.absolutePath}`
-          );
-          continue;
-        }
-        const json = JSON.stringify(
-          excludeNone(trajectory),
-          null,
-          2
-        );
-        const atifPath = file.absolutePath.replace(/\.jsonl$/, ".atif.json");
-        newFiles.push({
-          sourceName: file.sourceName,
-          absolutePath: atifPath,
-          repoPath: file.repoPath,
-          metadata: { ...file.metadata, isAtif: true },
-          content: Buffer.from(json, "utf-8")
-        });
-      } catch (err) {
-        appendLog(
-          "warn",
-          `normalize: skipped ATIF for source=${file.sourceName} session=${sessionId ?? "<unknown>"} file=${file.absolutePath}: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    return { ...group, files: newFiles };
-  }
-};
-
-// src/upload-state.ts
-import crypto2 from "crypto";
-import fs10 from "fs";
-import os5 from "os";
-import path14 from "path";
-var CURRENT_SCHEMA_VERSION2 = 1;
-var DEFAULT_STATE_DIR = path14.join(
-  os5.homedir(),
-  ".hillclimb",
-  "agent-uploads"
-);
-var DEFAULT_LOCK_WAIT_MS = 5 * 60 * 1e3;
-var DEFAULT_LOCK_RETRY_DELAY_MS = 500;
-var DEFAULT_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
-function stateDir2() {
-  return process.env.HILLCLIMB_UPLOAD_STATE_DIR ?? DEFAULT_STATE_DIR;
-}
-function readPositiveEnvMs(name, fallback) {
-  const raw = process.env[name];
-  if (raw === void 0) return fallback;
-  const n = Number(raw);
-  return Number.isFinite(n) && n >= 0 ? n : fallback;
-}
-function stateTtlMs() {
-  return readPositiveEnvMs(
-    "HILLCLIMB_UPLOAD_STATE_TTL_MS",
-    DEFAULT_STATE_TTL_MS
-  );
-}
-function lockRetryDelayMs() {
-  return Math.max(
-    1,
-    readPositiveEnvMs(
-      "HILLCLIMB_UPLOAD_LOCK_RETRY_DELAY_MS",
-      DEFAULT_LOCK_RETRY_DELAY_MS
-    )
-  );
+function cursorFileFor(repoRoot, tool, sessionId) {
+  return `${stateFileFor(repoRoot, tool, sessionId)}.cursor.json`;
 }
-function lockRetries() {
-  return Math.max(
-    1,
-    Math.ceil(
-      readPositiveEnvMs("HILLCLIMB_UPLOAD_LOCK_WAIT_MS", DEFAULT_LOCK_WAIT_MS) / lockRetryDelayMs()
-    )
-  );
-}
-function stateFileFor(repoRoot, tool, sessionId) {
-  const hash = crypto2.createHash("sha256").update(`${path14.resolve(repoRoot)}\0${tool}\0${sessionId}`).digest("hex").slice(0, 16);
-  return path14.join(stateDir2(), `${hash}.json`);
-}
-function lockFileFor(repoRoot, tool, sessionId) {
-  return `${stateFileFor(repoRoot, tool, sessionId)}.lock`;
-}
-async function readUploadState(repoRoot, tool, sessionId) {
+async function readCursorState(repoRoot, tool, sessionId) {
   try {
-    const raw = await fs10.promises.readFile(
-      stateFileFor(repoRoot, tool, sessionId),
+    const raw = await fs12.promises.readFile(
+      cursorFileFor(repoRoot, tool, sessionId),
       "utf-8"
     );
     const parsed = JSON.parse(raw);
-    if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION2) return null;
+    if (typeof parsed.contributionId !== "string" || typeof parsed.epoch !== "number" || typeof parsed.turnCount !== "number" || typeof parsed.rawByteOffset !== "number" || typeof parsed.rawPrefixSha256 !== "string" || typeof parsed.snapshotUploaded !== "boolean") {
+      return null;
+    }
     return parsed;
   } catch {
     return null;
   }
 }
-async function writeUploadState(state) {
-  const file = stateFileFor(state.repoRoot, state.tool, state.sessionId);
-  await fs10.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+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 fs10.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+  await fs12.promises.writeFile(tmp, JSON.stringify(cursor, null, 2), {
     mode: 384
   });
-  await fs10.promises.rename(tmp, file);
-}
-async function deleteUploadState(repoRoot, tool, sessionId) {
-  try {
-    await fs10.promises.unlink(stateFileFor(repoRoot, tool, sessionId));
-  } catch {
-  }
+  await fs12.promises.rename(tmp, file);
 }
 async function acquireLock2(repoRoot, tool, sessionId, retries = lockRetries(), delayMs = lockRetryDelayMs()) {
   const lockPath = lockFileFor(repoRoot, tool, sessionId);
-  await fs10.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+  await fs12.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
   for (let i = 0; i < retries; i++) {
     try {
-      const fd = await fs10.promises.open(
+      const fd = await fs12.promises.open(
         lockPath,
-        fs10.constants.O_CREAT | fs10.constants.O_EXCL | fs10.constants.O_WRONLY
+        fs12.constants.O_CREAT | fs12.constants.O_EXCL | fs12.constants.O_WRONLY
       );
       try {
         await fd.write(String(process.pid));
@@ -13511,7 +12088,7 @@ async function acquireLock2(repoRoot, tool, sessionId, retries = lockRetries(),
 }
 async function releaseLock2(repoRoot, tool, sessionId) {
   try {
-    await fs10.promises.unlink(lockFileFor(repoRoot, tool, sessionId));
+    await fs12.promises.unlink(lockFileFor(repoRoot, tool, sessionId));
   } catch {
   }
 }
@@ -13523,20 +12100,43 @@ async function withUploadLock(repoRoot, tool, sessionId, fn) {
     await releaseLock2(repoRoot, tool, sessionId);
   }
 }
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
 async function sweepStaleUploadStates(ttlMs = stateTtlMs(), now = Date.now()) {
   let entries;
   try {
-    entries = await fs10.promises.readdir(stateDir2(), { withFileTypes: true });
+    entries = await fs12.promises.readdir(stateDir2(), { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (!entry.isFile()) continue;
-    const file = path14.join(stateDir2(), entry.name);
+    const file = path13.join(stateDir2(), entry.name);
     try {
-      const st = await fs10.promises.stat(file);
+      if (entry.name.endsWith(".lock")) {
+        const raw = await fs12.promises.readFile(file, "utf-8").catch(() => "");
+        const pid = Number.parseInt(raw.trim(), 10);
+        if (Number.isInteger(pid) && pid > 0) {
+          if (!isProcessAlive(pid)) {
+            await fs12.promises.unlink(file);
+          }
+        } else {
+          const st2 = await fs12.promises.stat(file);
+          if (now - st2.mtimeMs > STALE_LOCK_TTL_MS) {
+            await fs12.promises.unlink(file);
+          }
+        }
+        continue;
+      }
+      const st = await fs12.promises.stat(file);
       if (now - st.mtimeMs > ttlMs) {
-        await fs10.promises.unlink(file);
+        await fs12.promises.unlink(file);
       }
     } catch {
     }
@@ -13552,20 +12152,17 @@ async function readStdin() {
   }
   return Buffer.concat(chunks).toString("utf-8");
 }
-function sanitize2(value) {
-  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
-}
 function formatEpochSeconds2(date) {
   return String(Math.floor(date.getTime() / 1e3));
 }
 function newFlowId() {
-  return crypto3.randomBytes(3).toString("hex");
+  return crypto4.randomBytes(3).toString("hex");
 }
 function lineHasAssistant(line) {
   return line.includes('"type":"assistant"') || line.includes('"role":"assistant"') || line.includes('"type":"assistant.');
 }
 async function hasAssistantMessage(transcriptPath) {
-  const stream = fs11.createReadStream(transcriptPath, { encoding: "utf-8" });
+  const stream = fs13.createReadStream(transcriptPath, { encoding: "utf-8" });
   let buffer = "";
   try {
     for await (const chunk of stream) {
@@ -13587,15 +12184,6 @@ async function hasAssistantMessage(transcriptPath) {
   }
   return false;
 }
-function hashFileSha256(file) {
-  return new Promise((resolve, reject) => {
-    const hash = crypto3.createHash("sha256");
-    const stream = fs11.createReadStream(file);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("error", reject);
-    stream.on("end", () => resolve(hash.digest("hex")));
-  });
-}
 async function resolveSourceTool(payload, repoRoot) {
   const inferred = inferSourceToolFromPayload(payload);
   if (inferred) return inferred;
@@ -13636,7 +12224,7 @@ function summarizePayload(payload) {
   });
 }
 async function codexSessionIdFromFile(filePath) {
-  const stream = fs11.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs13.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -13656,17 +12244,17 @@ async function codexSessionIdFromFile(filePath) {
   return null;
 }
 async function findCodexTranscriptPath(sessionId) {
-  const sessionsDir = process.env.HILLCLIMB_CODEX_SESSIONS_DIR ?? path15.join(os6.homedir(), ".codex", "sessions");
+  const sessionsDir = process.env.HILLCLIMB_CODEX_SESSIONS_DIR ?? path14.join(os6.homedir(), ".codex", "sessions");
   const candidates = [];
   async function walk(dir) {
     let entries;
     try {
-      entries = await fs11.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs13.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path15.join(dir, entry.name);
+      const full = path14.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl") && entry.name.includes(sessionId)) {
@@ -13706,7 +12294,7 @@ function resolveCursorTranscriptPath(payload) {
   const workspace = payload.workspace_roots?.[0];
   if (!id || !workspace) return void 0;
   const encoded = workspace.replace(/^\//, "").replace(/\//g, "-");
-  return path15.join(
+  return path14.join(
     os6.homedir(),
     ".cursor",
     "projects",
@@ -13735,6 +12323,7 @@ async function runUploadInner(payload) {
   const sessionId = resolveHookSessionId(payload);
   const cwd = resolveHookCwd(payload);
   const eventKind = classifyHookEvent(payload.hook_event_name);
+  const recordedAt = Date.now();
   if (!sessionId || !cwd) {
     appendLog(
       "warn",
@@ -13756,101 +12345,221 @@ async function runUploadInner(payload) {
     payload.tool = "unknown";
     return false;
   }
-  payload.tool = sourceTool;
-  appendLog(
-    "info",
-    `[${sessionId}] payload parsed (tool=${sourceTool}, cwd=${cwd}, event=${eventKind ?? "?"})`
-  );
-  await selfHealHook(repoRoot, sourceTool);
-  const transcriptPath = await resolveTranscriptPath(
-    payload,
-    sourceTool,
-    sessionId
-  );
-  if (!transcriptPath) {
+  payload.tool = sourceTool;
+  appendLog(
+    "info",
+    `[${sessionId}] payload parsed (tool=${sourceTool}, cwd=${cwd}, event=${eventKind ?? "?"})`
+  );
+  await selfHealHook(repoRoot, sourceTool);
+  const transcriptPath = await resolveTranscriptPath(
+    payload,
+    sourceTool,
+    sessionId
+  );
+  if (!transcriptPath) {
+    appendLog(
+      "warn",
+      `Skipping upload: missing required hook fields (session_id=true, transcript_path=false, cwd=true)`
+    );
+    return false;
+  }
+  const transcriptResolved = path14.resolve(transcriptPath);
+  try {
+    const stat = await fs13.promises.stat(transcriptResolved);
+    if (!stat.isFile()) {
+      appendLog(
+        "warn",
+        `Skipping session ${sessionId}: transcript_path is not a file: ${transcriptResolved}`
+      );
+      return false;
+    }
+  } catch (err) {
+    appendLog(
+      "warn",
+      `Skipping session ${sessionId}: transcript_path not readable (${transcriptResolved}): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return false;
+  }
+  if (!await hasAssistantMessage(transcriptResolved)) {
+    appendLog(
+      "info",
+      `Skipping session ${sessionId}: transcript contains no assistant messages (nothing to upload).`
+    );
+    return false;
+  }
+  return await uploadSession({
+    sessionId,
+    transcriptPath: transcriptResolved,
+    repoRoot,
+    config,
+    sourceTool,
+    eventKind,
+    recordedAt
+  });
+}
+var AGENT_MAX_UPLOAD_BYTES = 1024 * 1024 * 1024;
+var CLI_VERSION = "0.7.0";
+function makeTranscriptGroup(repoRoot, sourceTool, transcriptPath, content) {
+  const sourceFile = {
+    sourceName: sourceTool,
+    absolutePath: transcriptPath,
+    repoPath: repoRoot,
+    content
+  };
+  return {
+    repoPath: 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) => path14.join(repoRoot, n));
+  const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
+  const chain = [];
+  if (secretResult.values.size > 0) {
+    chain.push(new RedactMiddleware(secretResult.values));
+  }
+  chain.push(new PatternRedactMiddleware());
+  return chain;
+}
+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);
+  }
+  const file = group.files.find((f) => f.absolutePath === transcriptPath);
+  if (!file?.content) {
+    throw new Error("redacted tail missing from middleware output");
+  }
+  return file.content;
+}
+async function handleUploadFailure(err, sessionId, repoRoot, sourceTool) {
+  if (err instanceof UploadTooLargeError) {
+    appendLog(
+      "error",
+      `Session ${sessionId} upload skipped: ${err.message}. The transcript snapshot exceeds the platform limit; later turns will keep failing until the session is split or the limit raised.`
+    );
+    return false;
+  }
+  if (err instanceof PlatformError && err.status === 401) {
     appendLog(
-      "warn",
-      `Skipping upload: missing required hook fields (session_id=true, transcript_path=false, cwd=true)`
+      "error",
+      `Session ${sessionId} upload failed: authentication expired. Re-run \`npx hillclimb\` in ${repoRoot}.`
     );
     return false;
   }
-  const transcriptResolved = path15.resolve(transcriptPath);
-  try {
-    const stat = await fs11.promises.stat(transcriptResolved);
-    if (!stat.isFile()) {
-      appendLog(
-        "warn",
-        `Skipping session ${sessionId}: transcript_path is not a file: ${transcriptResolved}`
-      );
-      return false;
-    }
-  } catch (err) {
+  if (err instanceof PlatformError && err.status === 400 && /too big|sizebytes/i.test(err.message)) {
     appendLog(
-      "warn",
-      `Skipping session ${sessionId}: transcript_path not readable (${transcriptResolved}): ${err instanceof Error ? err.message : String(err)}`
+      "error",
+      `Session ${sessionId} upload skipped: the platform rejected the declared size (${err.message}). The server's upload limit is below this CLI's; the upload will keep failing until the platform limit is raised.`
     );
     return false;
   }
-  if (!await hasAssistantMessage(transcriptResolved)) {
+  if (err instanceof PlatformError && err.status === 404 && err.code === "CONTRIBUTION_NOT_FOUND") {
+    await deleteUploadState(repoRoot, sourceTool, sessionId);
     appendLog(
-      "info",
-      `Skipping session ${sessionId}: transcript contains no assistant messages (nothing to upload).`
+      "warn",
+      `Session ${sessionId} upload failed: contribution deleted server-side; local state cleared so the next turn re-creates it.`
     );
     return false;
   }
-  return await uploadSession({
+  appendLog(
+    "error",
+    `Session ${sessionId} upload failed: ${err instanceof Error ? err.message : String(err)}`
+  );
+  return false;
+}
+async function uploadSession(args) {
+  const {
     sessionId,
-    transcriptPath: transcriptResolved,
+    transcriptPath,
     repoRoot,
     config,
     sourceTool,
-    eventKind
-  });
-}
-async function uploadSession(args) {
-  const { sessionId, transcriptPath, repoRoot, config, sourceTool, eventKind } = args;
+    eventKind,
+    recordedAt
+  } = args;
   const isSessionEnd = eventKind === "sessionEnd";
+  const eventLabel = isSessionEnd ? "SessionEnd" : "Stop";
   return await withUploadLock(repoRoot, sourceTool, sessionId, async () => {
     const prior = await readUploadState(repoRoot, sourceTool, sessionId);
-    let transcriptSize;
-    let transcriptSha256;
-    try {
-      transcriptSize = (await fs11.promises.stat(transcriptPath)).size;
-      transcriptSha256 = await hashFileSha256(transcriptPath);
-    } catch {
-    }
-    if (prior?.contributionId && transcriptSize !== void 0 && transcriptSha256 !== void 0 && transcriptSize === prior.lastTranscriptSize && transcriptSha256 === prior.lastTranscriptSha256) {
-      appendLog(
-        "info",
-        `[${sessionId}] skipping ${sourceTool} ${isSessionEnd ? "SessionEnd" : "Stop"} upload (transcript unchanged at ${transcriptSize} bytes${isSessionEnd ? "; local state cleared" : ""})`
-      );
-      if (isSessionEnd) {
-        await deleteUploadState(repoRoot, sourceTool, sessionId);
+    let cursor = null;
+    let adoptedLegacy = false;
+    let restored = null;
+    if (prior?.contributionId && prior.snapshotUploaded && prior.rawByteOffset !== void 0 && prior.rawPrefixSha256 !== void 0) {
+      cursor = {
+        rawByteOffset: prior.rawByteOffset,
+        rawPrefixSha256: prior.rawPrefixSha256
+      };
+    } else if (prior?.contributionId && prior.rawByteOffset === void 0) {
+      const sidecar = await readCursorState(repoRoot, sourceTool, sessionId);
+      if (sidecar && sidecar.contributionId !== prior.contributionId) {
+        appendLog(
+          "info",
+          `[${sessionId}] ignoring sidecar cursor for stale contribution ${sidecar.contributionId} (state has ${prior.contributionId})`
+        );
+      }
+      if (sidecar && sidecar.contributionId === prior.contributionId && sidecar.snapshotUploaded) {
+        cursor = {
+          rawByteOffset: sidecar.rawByteOffset,
+          rawPrefixSha256: sidecar.rawPrefixSha256
+        };
+        restored = sidecar;
+        appendLog(
+          "info",
+          `[${sessionId}] restored epoch cursor from sidecar after old-CLI state rewrite (epoch=${sidecar.epoch}, turn=${sidecar.turnCount}, offset=${sidecar.rawByteOffset})`
+        );
+      } else if (prior.lastTranscriptSize !== void 0 && prior.lastTranscriptSha256 !== void 0) {
+        const candidate = {
+          rawByteOffset: prior.lastTranscriptSize,
+          rawPrefixSha256: prior.lastTranscriptSha256
+        };
+        if (await cursorMatchesFile(transcriptPath, candidate)) {
+          cursor = candidate;
+          adoptedLegacy = true;
+          appendLog(
+            "info",
+            `[${sessionId}] adopting last uploaded full zip as epoch-001 baseline (legacy state bootstrap, offset=${candidate.rawByteOffset})`
+          );
+        } else {
+          appendLog(
+            "info",
+            `[${sessionId}] legacy state present but prefix mismatch or mid-line offset (offset=${candidate.rawByteOffset}) \u2014 will re-baseline with a fresh snapshot`
+          );
+        }
       }
-      return true;
     }
-    const now = /* @__PURE__ */ new Date();
-    const sourceFile = {
-      sourceName: sourceTool,
-      absolutePath: transcriptPath,
-      repoPath: repoRoot
-    };
-    const group = {
-      repoPath: repoRoot,
-      label: path15.basename(repoRoot),
-      files: [sourceFile],
-      sourceNames: [sourceTool],
-      lastModified: now
-    };
-    const envFileNames = await discoverEnvFiles(repoRoot);
-    const envFilePaths = envFileNames.map((n) => path15.join(repoRoot, n));
-    const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
-    const mwChain = [];
-    if (secretResult.values.size > 0) {
-      mwChain.push(new RedactMiddleware(secretResult.values));
+    let mode;
+    let transition = "initial";
+    let tail;
+    let nextCursor;
+    if (cursor) {
+      const evaluation = await evaluateTranscript(transcriptPath, cursor);
+      if (evaluation.kind === "unchanged") {
+        appendLog(
+          "info",
+          `[${sessionId}] skipping ${sourceTool} ${eventLabel} upload (no new complete transcript lines past offset ${cursor.rawByteOffset}${isSessionEnd ? "; local state cleared" : ""})`
+        );
+        if (isSessionEnd) {
+          await deleteUploadState(repoRoot, sourceTool, sessionId);
+        }
+        return true;
+      }
+      if (evaluation.kind === "append") {
+        mode = "patch";
+        tail = evaluation.tail;
+        nextCursor = evaluation.nextCursor;
+      } else {
+        mode = "snapshot";
+        transition = evaluation.kind;
+      }
+    } else {
+      mode = "snapshot";
+      transition = prior ? "state-lost" : "initial";
     }
-    mwChain.push(new PatternRedactMiddleware());
-    mwChain.push(new NormalizeMiddleware());
     const identity = await loadIdentity(config.apiBaseUrl);
     if (!identity) {
       appendLog(
@@ -13863,6 +12572,159 @@ async function uploadSession(args) {
       config.apiBaseUrl,
       identity.sessionCookie
     );
+    const now = /* @__PURE__ */ new Date();
+    const redactChain = await buildRedactChain(repoRoot);
+    const transcriptArchivePath = archivePathFor({
+      sourceName: sourceTool,
+      absolutePath: transcriptPath
+    });
+    const alreadySubmitted = prior?.submitted ?? false;
+    const submitThisUpload = config.autoSubmit && !alreadySubmitted;
+    if (mode === "patch" && cursor && tail && nextCursor && prior?.contributionId) {
+      const baseCursor = cursor;
+      const contributionId2 = prior.contributionId;
+      const epoch2 = prior.epoch ?? restored?.epoch ?? 1;
+      const turn = (prior.turnCount ?? restored?.turnCount ?? 0) + 1;
+      appendLog(
+        "info",
+        `[${sessionId}] ${sourceTool} ${eventLabel} upload \u2192 patch epoch=${epoch2} turn=${turn} (${tail.length} raw tail bytes, contribution ${contributionId2})`
+      );
+      try {
+        const redactedTail = await redactTail(
+          tail,
+          repoRoot,
+          sourceTool,
+          transcriptPath,
+          redactChain
+        );
+        if (adoptedLegacy) {
+          await uploadArtifact(
+            client,
+            contributionId2,
+            metaFilename(epoch2, recordedAt),
+            "application/json",
+            buildEpochMeta({
+              sessionId,
+              tool: sourceTool,
+              cliVersion: CLI_VERSION,
+              epoch: epoch2,
+              transitionKind: "legacy-adopted",
+              baseline: "legacy-latest-zip",
+              transcriptArchivePath,
+              cursor: baseCursor,
+              recordedAt
+            })
+          );
+        }
+        await uploadArtifact(
+          client,
+          contributionId2,
+          patchFilename(epoch2, turn, recordedAt),
+          "application/gzip",
+          gzipPatch(redactedTail),
+          AGENT_MAX_UPLOAD_BYTES
+        );
+      } catch (err) {
+        return handleUploadFailure(err, sessionId, repoRoot, sourceTool);
+      }
+      const persistState = async (submitted2) => {
+        await writeUploadState({
+          schemaVersion: CURRENT_SCHEMA_VERSION2,
+          sessionId,
+          tool: sourceTool,
+          repoRoot,
+          projectId: config.projectId,
+          contributionId: contributionId2,
+          submitted: submitted2,
+          uploadCount: (prior.uploadCount ?? 0) + (adoptedLegacy ? 2 : 1),
+          firstUploadedAt: prior.firstUploadedAt ?? now.toISOString(),
+          lastUploadedAt: now.toISOString(),
+          // Mirrors the cursor from here on: describes the raw bytes covered
+          // by uploads, not the whole file (which may end in a torn line). An
+          // old CLI reading these sees a mismatch against the grown file and
+          // safely falls back to a full-zip upload.
+          lastTranscriptSize: nextCursor.rawByteOffset,
+          lastTranscriptSha256: nextCursor.rawPrefixSha256,
+          epoch: epoch2,
+          turnCount: turn,
+          rawByteOffset: nextCursor.rawByteOffset,
+          rawPrefixSha256: nextCursor.rawPrefixSha256,
+          snapshotUploaded: true
+        });
+        await writeCursorState(repoRoot, sourceTool, sessionId, {
+          contributionId: contributionId2,
+          epoch: epoch2,
+          turnCount: turn,
+          rawByteOffset: nextCursor.rawByteOffset,
+          rawPrefixSha256: nextCursor.rawPrefixSha256,
+          snapshotUploaded: true
+        });
+      };
+      await persistState(alreadySubmitted);
+      let submitted = alreadySubmitted;
+      if (submitThisUpload) {
+        try {
+          appendLog("info", `submitting contribution ${contributionId2}`);
+          await client.submitContribution(contributionId2);
+          submitted = true;
+          appendLog("info", `contribution ${contributionId2} submitted`);
+        } catch (err) {
+          if (err instanceof PlatformError && err.status === 409 && err.code === "CONTRIBUTION_WRONG_STATE") {
+            submitted = true;
+            appendLog(
+              "info",
+              `contribution ${contributionId2} was already submitted (409); recording locally`
+            );
+          } else {
+            appendLog(
+              "warn",
+              `[${sessionId}] submit failed (patch is durable; will retry next turn): ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        if (submitted) await persistState(true);
+      }
+      appendLog(
+        "info",
+        `Uploaded session ${sessionId} patch epoch=${epoch2} turn=${turn} to contribution ${contributionId2} (offset ${baseCursor.rawByteOffset} \u2192 ${nextCursor.rawByteOffset})`
+      );
+      if (isSessionEnd) {
+        await deleteUploadState(repoRoot, sourceTool, sessionId);
+        appendLog(
+          "info",
+          `[${sessionId}] session complete \u2014 contribution ${contributionId2}, epoch ${epoch2}, ${turn} patch(es); local state cleared`
+        );
+      }
+      return true;
+    }
+    let raw;
+    try {
+      raw = await fs13.promises.readFile(transcriptPath);
+    } catch (err) {
+      if (err.code === "ERR_FS_FILE_TOO_LARGE") {
+        appendLog(
+          "error",
+          `Session ${sessionId} snapshot impossible: transcript is over Node's 2 GiB read limit (${transcriptPath}). Established patch chains keep working, but a (re-)baseline of this session cannot upload until snapshots are built streaming.`
+        );
+      } else {
+        appendLog(
+          "warn",
+          `Skipping session ${sessionId}: transcript unreadable (${transcriptPath}): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      return false;
+    }
+    const truncated = truncateAtLastNewline(raw);
+    if (!truncated) {
+      appendLog(
+        "info",
+        `[${sessionId}] skipping ${sourceTool} ${eventLabel} upload (no complete transcript line yet)`
+      );
+      if (isSessionEnd)
+        await deleteUploadState(repoRoot, sourceTool, sessionId);
+      return true;
+    }
+    const epoch = (prior?.epoch ?? restored?.epoch ?? 0) + 1;
     const shortId = sessionId.slice(0, 12);
     const toolLabels = {
       cursor: "Cursor",
@@ -13872,16 +12734,19 @@ async function uploadSession(args) {
       opencode: "opencode"
     };
     const toolLabel2 = toolLabels[sourceTool] ?? "Claude";
-    const epochSeconds = formatEpochSeconds2(now);
-    const seq = (prior?.uploadCount ?? 0) + 1;
-    const title = `${toolLabel2} session ${shortId} \u2014 ${epochSeconds}`;
+    const title = `${toolLabel2} session ${shortId} \u2014 ${formatEpochSeconds2(now)}`;
     const body = `Session ID: ${sessionId}
 Tool: ${toolLabel2}
 Repo: ${repoRoot}
 Uploaded: ${now.toISOString()}`;
-    const zipFilename = `${sourceTool}-${sanitize2(shortId)}-${epochSeconds}-${String(seq).padStart(3, "0")}.zip`;
-    const alreadySubmitted = prior?.submitted ?? false;
-    const submitThisUpload = config.autoSubmit && !alreadySubmitted;
+    const zipFilename = snapshotFilename(epoch, recordedAt);
+    const group = makeTranscriptGroup(
+      repoRoot,
+      sourceTool,
+      transcriptPath,
+      truncated.covered
+    );
+    const mwChain = redactChain;
     const output = new PlatformUploadOutput({
       client,
       projectId: config.projectId,
@@ -13891,6 +12756,7 @@ Uploaded: ${now.toISOString()}`;
       zipFilename,
       autoSubmit: submitThisUpload,
       existingContributionId: prior?.contributionId ?? void 0,
+      maxUploadBytes: AGENT_MAX_UPLOAD_BYTES,
       // Persist the new contribution id before the file PUT so a failed
       // upload can't make the next Stop create a second contribution.
       onContributionCreated: (id) => writeUploadState({
@@ -13908,10 +12774,10 @@ Uploaded: ${now.toISOString()}`;
         lastTranscriptSha256: prior?.lastTranscriptSha256
       })
     });
-    const reuseDesc = prior?.contributionId ? `reusing contribution ${prior.contributionId} (file #${seq})` : prior ? "new contribution (file #1; prior state had no contribution \u2014 earlier create may have failed)" : "new contribution (file #1; first upload for session)";
+    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} ${isSessionEnd ? "SessionEnd" : "Stop"} upload \u2192 ${reuseDesc}`
+      `[${sessionId}] ${sourceTool} ${eventLabel} upload \u2192 snapshot epoch=${epoch} transition=${transition} (${truncated.covered.length} raw bytes, ${reuseDesc})`
     );
     let contributionId;
     try {
@@ -13919,20 +12785,36 @@ Uploaded: ${now.toISOString()}`;
         selectedSources: [sourceTool]
       });
     } catch (err) {
-      if (err instanceof PlatformError && err.status === 401) {
-        appendLog(
-          "error",
-          `Session ${sessionId} upload failed: authentication expired. Re-run \`npx hillclimb\` in ${repoRoot}.`
-        );
-        return false;
-      }
+      return handleUploadFailure(err, sessionId, repoRoot, sourceTool);
+    }
+    let metaUploaded = 0;
+    try {
+      await uploadArtifact(
+        client,
+        contributionId,
+        metaFilename(epoch, recordedAt),
+        "application/json",
+        buildEpochMeta({
+          sessionId,
+          tool: sourceTool,
+          cliVersion: CLI_VERSION,
+          epoch,
+          transitionKind: transition,
+          baseline: "snapshot",
+          snapshotFilename: zipFilename,
+          transcriptArchivePath,
+          cursor: truncated.cursor,
+          recordedAt
+        })
+      );
+      metaUploaded = 1;
+    } catch (err) {
       appendLog(
-        "error",
-        `Session ${sessionId} upload failed: ${err instanceof Error ? err.message : String(err)}`
+        "warn",
+        `[${sessionId}] epoch meta upload failed (snapshot is durable; continuing): ${err instanceof Error ? err.message : String(err)}`
       );
-      return false;
     }
-    const next = {
+    await writeUploadState({
       schemaVersion: CURRENT_SCHEMA_VERSION2,
       sessionId,
       tool: sourceTool,
@@ -13940,22 +12822,35 @@ Uploaded: ${now.toISOString()}`;
       projectId: config.projectId,
       contributionId,
       submitted: alreadySubmitted || submitThisUpload,
-      uploadCount: seq,
+      uploadCount: (prior?.uploadCount ?? 0) + 1 + metaUploaded,
       firstUploadedAt: prior?.firstUploadedAt ?? now.toISOString(),
       lastUploadedAt: now.toISOString(),
-      lastTranscriptSize: transcriptSize,
-      lastTranscriptSha256: transcriptSha256
-    };
-    await writeUploadState(next);
+      // Mirrors the cursor (see patch path).
+      lastTranscriptSize: truncated.cursor.rawByteOffset,
+      lastTranscriptSha256: truncated.cursor.rawPrefixSha256,
+      epoch,
+      turnCount: 0,
+      rawByteOffset: truncated.cursor.rawByteOffset,
+      rawPrefixSha256: truncated.cursor.rawPrefixSha256,
+      snapshotUploaded: true
+    });
+    await writeCursorState(repoRoot, sourceTool, sessionId, {
+      contributionId,
+      epoch,
+      turnCount: 0,
+      rawByteOffset: truncated.cursor.rawByteOffset,
+      rawPrefixSha256: truncated.cursor.rawPrefixSha256,
+      snapshotUploaded: true
+    });
     appendLog(
       "info",
-      `Uploaded session ${sessionId} to project ${config.projectSlug} (${config.projectId}) as contribution ${contributionId} (seq=${seq})`
+      `Uploaded session ${sessionId} snapshot epoch=${epoch} to project ${config.projectSlug} (${config.projectId}) as contribution ${contributionId}`
     );
     if (isSessionEnd) {
       await deleteUploadState(repoRoot, sourceTool, sessionId);
       appendLog(
         "info",
-        `[${sessionId}] session complete \u2014 contribution ${contributionId}, ${seq} file(s); local state cleared`
+        `[${sessionId}] session complete \u2014 contribution ${contributionId}, epoch ${epoch} snapshot; local state cleared`
       );
     }
     return true;
@@ -14087,18 +12982,18 @@ async function runUploadWorker() {
 
 // src/git-traces/index.ts
 import { spawn as spawn3 } from "child_process";
-import crypto5 from "crypto";
+import crypto6 from "crypto";
 
 // src/git-traces/handlers.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import path18 from "path";
+import path17 from "path";
 
 // src/git-traces/git-ops.ts
 import { execFileSync as execFileSync2, spawnSync } from "child_process";
-import fs12 from "fs";
+import fs14 from "fs";
 import os7 from "os";
-import path16 from "path";
-import { gzipSync } from "zlib";
+import path15 from "path";
+import { gzipSync as gzipSync2 } from "zlib";
 var GIT_COMMAND_TIMEOUT_MS = 12e4;
 var EXEC_OPTS = {
   timeout: GIT_COMMAND_TIMEOUT_MS,
@@ -14203,8 +13098,8 @@ var EXCLUDED_SNAPSHOT_BASENAMES = /* @__PURE__ */ new Set([
 ]);
 var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 function isExcludedSnapshotPath(filePath) {
-  if (EXCLUDED_SNAPSHOT_BASENAMES.has(path16.basename(filePath))) return true;
-  return EXCLUDED_SNAPSHOT_EXTENSIONS.has(path16.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);
@@ -14224,16 +13119,16 @@ function readTreeBlobHead(repoRoot, sha) {
 function readWorkingFileHead(absPath) {
   let fd = null;
   try {
-    fd = fs12.openSync(absPath, "r");
+    fd = fs14.openSync(absPath, "r");
     const buffer = Buffer.alloc(BINARY_SNIFF_BYTES);
-    const bytesRead = fs12.readSync(fd, buffer, 0, BINARY_SNIFF_BYTES, 0);
+    const bytesRead = fs14.readSync(fd, buffer, 0, BINARY_SNIFF_BYTES, 0);
     return buffer.subarray(0, bytesRead);
   } catch {
     return null;
   } finally {
     if (fd !== null) {
       try {
-        fs12.closeSync(fd);
+        fs14.closeSync(fd);
       } catch {
       }
     }
@@ -14411,7 +13306,7 @@ function removePathsFromIndex(repoRoot, env, paths) {
 function filterOmittedFilesFromTree(repoRoot, treeSha, options = {}) {
   const omittedFiles = listOmittedTreeFiles(repoRoot, treeSha, options);
   if (omittedFiles.length === 0) return treeSha;
-  const tmpIndex = path16.join(
+  const tmpIndex = path15.join(
     os7.tmpdir(),
     `hillclimb-filter-${Date.now()}-${process.pid}`
   );
@@ -14426,7 +13321,7 @@ function filterOmittedFilesFromTree(repoRoot, treeSha, options = {}) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs12.unlinkSync(tmpIndex);
+      fs14.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -14443,8 +13338,8 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
   for (const relPath of list.split("\0")) {
     if (!relPath) continue;
     try {
-      const absPath = path16.join(repoRoot, relPath);
-      const stat = fs12.lstatSync(absPath);
+      const absPath = path15.join(repoRoot, relPath);
+      const stat = fs14.lstatSync(absPath);
       const reason = classifyOmission(
         relPath,
         stat.size,
@@ -14464,7 +13359,7 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
     }
   }
   if (kept.length === 0) return null;
-  const tmpIndex = path16.join(
+  const tmpIndex = path15.join(
     os7.tmpdir(),
     `hillclimb-untracked-${Date.now()}-${process.pid}`
   );
@@ -14477,7 +13372,7 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs12.unlinkSync(tmpIndex);
+      fs14.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -14494,7 +13389,7 @@ function buildSnapshotTree(repoRoot, stashSha, options = {}) {
   const untrackedTree = buildUntrackedTree(repoRoot, options.omittedFiles);
   if (!untrackedTree || untrackedTree === EMPTY_TREE_SHA)
     return filteredTrackedTree;
-  const tmpIndex = path16.join(
+  const tmpIndex = path15.join(
     os7.tmpdir(),
     `hillclimb-index-${Date.now()}-${process.pid}`
   );
@@ -14522,7 +13417,7 @@ function buildSnapshotTree(repoRoot, stashSha, options = {}) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs12.unlinkSync(tmpIndex);
+      fs14.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -14536,7 +13431,7 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
   ]);
   const orphanRef = `refs/hillclimb/bundle/${sessionId}`;
   pinRef(repoRoot, orphanRef, orphanCommit);
-  const tmpFile = path16.join(
+  const tmpFile = path15.join(
     os7.tmpdir(),
     // Include the pid (like the other temp files in this module) so concurrent
     // git-traces workers — e.g. two sessions, or a parent + subagent — don't
@@ -14545,10 +13440,10 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
   );
   try {
     git(repoRoot, ["bundle", "create", tmpFile, orphanRef]);
-    return fs12.readFileSync(tmpFile);
+    return fs14.readFileSync(tmpFile);
   } finally {
     try {
-      fs12.unlinkSync(tmpFile);
+      fs14.unlinkSync(tmpFile);
     } catch {
     }
     deleteRef(repoRoot, orphanRef);
@@ -14574,7 +13469,7 @@ function createTreeDiffPatchGz(repoRoot, fromTreeSha, toTreeSha) {
     filteredToTreeSha
   ]);
   if (diff.length === 0) return null;
-  return Buffer.from(gzipSync(diff));
+  return Buffer.from(gzipSync2(diff));
 }
 function detectTransitionKind(repoRoot, prevHeadSha, nextHeadSha) {
   if (!prevHeadSha) return "initial";
@@ -14735,9 +13630,9 @@ function parseCommitFiles(repoRoot, sha) {
         oldPath
       });
     } else {
-      const path25 = parts[parts.length - 1];
-      indexByPath.set(path25, files.length);
-      files.push({ path: path25, 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")) {
@@ -14803,29 +13698,30 @@ function cleanupSessionRefs(repoRoot, sessionId) {
 }
 
 // src/git-traces/session-state.ts
-import crypto4 from "crypto";
-import fs13 from "fs";
+import crypto5 from "crypto";
+import fs15 from "fs";
 import os8 from "os";
-import path17 from "path";
+import path16 from "path";
 var CURRENT_SCHEMA_VERSION3 = 3;
-var DEFAULT_STATE_DIR2 = path17.join(os8.homedir(), ".hillclimb", "git-traces");
+var DEFAULT_STATE_DIR2 = path16.join(os8.homedir(), ".hillclimb", "git-traces");
 var LOCK_RETRIES2 = 120;
 var LOCK_RETRY_DELAY_MS2 = 500;
+var STALE_LOCK_TTL_MS2 = 60 * 60 * 1e3;
 function stateDir3() {
   return process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? DEFAULT_STATE_DIR2;
 }
 function stateFileForRepo(repoRoot, tool, sessionId) {
-  const hash = crypto4.createHash("sha256").update(
-    sessionId ? `${path17.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path17.resolve(repoRoot)}\0${tool}`
+  const hash = crypto5.createHash("sha256").update(
+    sessionId ? `${path16.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path16.resolve(repoRoot)}\0${tool}`
   ).digest("hex").slice(0, 16);
-  return path17.join(stateDir3(), `${hash}.json`);
+  return path16.join(stateDir3(), `${hash}.json`);
 }
-function lockFileForRepo(repoRoot, tool) {
-  return `${stateFileForRepo(repoRoot, tool)}.lock`;
+function lockFileForRepo(repoRoot, tool, sessionId) {
+  return `${stateFileForRepo(repoRoot, tool, sessionId)}.lock`;
 }
 async function readStateFile(file) {
   try {
-    const raw = await fs13.promises.readFile(file, "utf-8");
+    const raw = await fs15.promises.readFile(file, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION3) {
       return null;
@@ -14838,26 +13734,26 @@ async function readStateFile(file) {
 async function listScopedSessionStates(repoRoot, tool) {
   let entries;
   try {
-    entries = await fs13.promises.readdir(stateDir3(), { withFileTypes: true });
+    entries = await fs15.promises.readdir(stateDir3(), { withFileTypes: true });
   } catch {
     return [];
   }
   const states = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const file = path17.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 (path17.resolve(state.repoRoot) !== path17.resolve(repoRoot)) continue;
-    if (path17.resolve(file) !== path17.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 fs13.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs15.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -14868,26 +13764,26 @@ async function listScopedSessionStates(repoRoot, tool) {
 async function listSessionStatesForSession(tool, sessionId) {
   let entries;
   try {
-    entries = await fs13.promises.readdir(stateDir3(), { withFileTypes: true });
+    entries = await fs15.promises.readdir(stateDir3(), { withFileTypes: true });
   } catch {
     return [];
   }
   const states = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const file = path17.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 (path17.resolve(file) !== path17.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
+    if (path16.resolve(file) !== path16.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
       continue;
     }
     let mtimeMs = 0;
     try {
-      mtimeMs = (await fs13.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs15.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -14908,12 +13804,12 @@ async function readSessionState(repoRoot, tool, sessionId) {
 }
 async function writeSessionState(state, tool) {
   const file = stateFileForRepo(state.repoRoot, tool, state.sessionId);
-  await fs13.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
+  await fs15.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   const tmp = `${file}.tmp`;
-  await fs13.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+  await fs15.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
     mode: 384
   });
-  await fs13.promises.rename(tmp, file);
+  await fs15.promises.rename(tmp, file);
   const legacyFile = stateFileForRepo(state.repoRoot, tool);
   const legacy = await readStateFile(legacyFile);
   if (legacy?.sessionId === state.sessionId) {
@@ -14922,7 +13818,7 @@ async function writeSessionState(state, tool) {
 }
 async function deleteStateFile(file) {
   try {
-    await fs13.promises.unlink(file);
+    await fs15.promises.unlink(file);
   } catch {
   }
 }
@@ -14938,14 +13834,14 @@ async function deleteSessionState(repoRoot, tool, sessionId) {
   }
   await deleteStateFile(stateFileForRepo(repoRoot, tool));
 }
-async function acquireLock3(repoRoot, tool, retries = LOCK_RETRIES2, delayMs = LOCK_RETRY_DELAY_MS2) {
-  const lockPath = lockFileForRepo(repoRoot, tool);
-  await fs13.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
+async function acquireLock3(repoRoot, tool, sessionId, retries = LOCK_RETRIES2, delayMs = LOCK_RETRY_DELAY_MS2) {
+  const lockPath = lockFileForRepo(repoRoot, tool, sessionId);
+  await fs15.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   for (let i = 0; i < retries; i++) {
     try {
-      const fd = await fs13.promises.open(
+      const fd = await fs15.promises.open(
         lockPath,
-        fs13.constants.O_CREAT | fs13.constants.O_EXCL | fs13.constants.O_WRONLY
+        fs15.constants.O_CREAT | fs15.constants.O_EXCL | fs15.constants.O_WRONLY
       );
       await fd.write(String(process.pid));
       await fd.close();
@@ -14960,15 +13856,54 @@ async function acquireLock3(repoRoot, tool, retries = LOCK_RETRIES2, delayMs = L
   }
   throw new Error(`Failed to acquire lock after ${retries} retries`);
 }
-async function releaseLock3(repoRoot, tool) {
+async function releaseLock3(repoRoot, tool, sessionId) {
+  try {
+    await fs15.promises.unlink(lockFileForRepo(repoRoot, tool, sessionId));
+  } catch {
+  }
+}
+function isProcessAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function sweepStaleLockFiles(ttlMs = STALE_LOCK_TTL_MS2, now = Date.now()) {
+  let entries;
   try {
-    await fs13.promises.unlink(lockFileForRepo(repoRoot, tool));
+    entries = await fs15.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 = path16.join(stateDir3(), entry.name);
+    try {
+      const raw = await fs15.promises.readFile(file, "utf-8").catch(() => "");
+      const pid = Number.parseInt(raw.trim(), 10);
+      const havePid = Number.isInteger(pid) && pid > 0;
+      let reap;
+      if (havePid) {
+        reap = !isProcessAlive2(pid);
+      } else {
+        const st = await fs15.promises.stat(file);
+        reap = now - st.mtimeMs > ttlMs;
+      }
+      if (reap) {
+        await fs15.promises.unlink(file);
+        removed++;
+      }
+    } catch {
+    }
+  }
+  return removed;
 }
 
 // src/git-traces/handlers.ts
-var CLI_VERSION = "0.2.0";
+var CLI_VERSION2 = "0.7.0";
 var GIT_TRACES_SLUG = "git-traces";
 var MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
 var STALE_SCOPED_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -14985,12 +13920,12 @@ var TOOL_LABELS = {
 async function loadConfiguredRepos() {
   const file = await loadProjects();
   return Object.entries(file.projects).map(([repoRoot, config]) => ({
-    repoRoot: path18.resolve(repoRoot),
+    repoRoot: path17.resolve(repoRoot),
     config
   })).sort((a, b) => a.repoRoot.localeCompare(b.repoRoot));
 }
 function repoLabel(repoRoot) {
-  return path18.basename(repoRoot) || repoRoot;
+  return path17.basename(repoRoot) || repoRoot;
 }
 function resolveCwd2(payload) {
   return resolveHookCwd(payload);
@@ -14998,10 +13933,10 @@ function resolveCwd2(payload) {
 function resolveSessionId2(payload) {
   return resolveHookSessionId(payload);
 }
-function epochPrefix(epoch) {
+function epochPrefix2(epoch) {
   return `epoch-${String(epoch).padStart(3, "0")}`;
 }
-function turnSuffix(turn) {
+function turnSuffix2(turn) {
   return `turn-${String(turn).padStart(3, "0")}`;
 }
 function captureHeadSha(cwd) {
@@ -15046,18 +13981,18 @@ async function uploadFile(client, contributionId, filename, mimeType, buffer) {
   return true;
 }
 function canUploadEpochBaselineArtifacts(epoch, artifacts) {
-  const prefix = epochPrefix(epoch);
+  const prefix = epochPrefix2(epoch);
   return canUploadFile(`${prefix}-baseline.bundle`, artifacts.bundleBuffer) && canUploadFile(`${prefix}-baseline.json`, artifacts.metadataBuffer);
 }
 function pinEpochBaseline(repoRoot, sessionId, epoch) {
   const baselineSha = captureBaselineSha(repoRoot);
-  const baselineRefPrefix = `refs/hillclimb/baseline/${sessionId}/${epochPrefix(epoch)}`;
+  const baselineRefPrefix = `refs/hillclimb/baseline/${sessionId}/${epochPrefix2(epoch)}`;
   deleteRef(repoRoot, baselineRefPrefix);
   pinRef(repoRoot, `${baselineRefPrefix}/tracked`, baselineSha);
   return { baselineSha, headSha: captureHeadSha(repoRoot) };
 }
 function pinFrozenBaselineTree(repoRoot, sessionId, epoch, baselineTreeSha) {
-  const prefix = epochPrefix(epoch);
+  const prefix = epochPrefix2(epoch);
   const commit = execGit(repoRoot, [
     "commit-tree",
     baselineTreeSha,
@@ -15080,7 +14015,7 @@ function freezeEpochBaseline(params) {
     transitionKind,
     startedAt
   } = params;
-  const prefix = epochPrefix(epoch);
+  const prefix = epochPrefix2(epoch);
   try {
     const { baselineSha, headSha } = pinEpochBaseline(
       repoRoot,
@@ -15096,7 +14031,7 @@ function freezeEpochBaseline(params) {
       sessionId,
       tool,
       baselineSha,
-      CLI_VERSION,
+      CLI_VERSION2,
       epoch,
       prevHeadSha,
       transitionKind,
@@ -15115,7 +14050,7 @@ function freezeEpochBaseline(params) {
 }
 function buildFrozenEpochBaselineArtifacts(params) {
   const { repoRoot, sessionId, epoch, baselineTreeSha, baselineMetadata } = params;
-  const prefix = epochPrefix(epoch);
+  const prefix = epochPrefix2(epoch);
   try {
     const bundleBuffer = createBundleFromTree(
       repoRoot,
@@ -15146,7 +14081,7 @@ function buildEpochBaselineArtifacts(params) {
     transitionKind,
     startedAt
   } = params;
-  const prefix = epochPrefix(epoch);
+  const prefix = epochPrefix2(epoch);
   try {
     const omittedFiles = [];
     const baselineTreeSha = buildSnapshotTree(repoRoot, baselineSha, {
@@ -15157,7 +14092,7 @@ function buildEpochBaselineArtifacts(params) {
       sessionId,
       tool,
       baselineSha,
-      CLI_VERSION,
+      CLI_VERSION2,
       epoch,
       prevHeadSha,
       transitionKind,
@@ -15181,7 +14116,7 @@ function buildEpochBaselineArtifacts(params) {
 }
 async function uploadEpochBaselineArtifacts(params) {
   const { client, contributionId, epoch, artifacts } = params;
-  const prefix = epochPrefix(epoch);
+  const prefix = epochPrefix2(epoch);
   if (!canUploadEpochBaselineArtifacts(epoch, artifacts)) return false;
   const bundleUploaded = await uploadFile(
     client,
@@ -15302,13 +14237,26 @@ async function cleanupStaleScopedSessionStates(repoRoot, tool, currentSessionId,
     const startedAtMs = Date.parse(state.startedAt);
     const ageBaseMs = Number.isNaN(startedAtMs) ? mtimeMs : startedAtMs;
     if (nowMs - ageBaseMs <= ttlMs) continue;
-    appendLog(
-      "info",
-      `git-traces: cleaning up stale scoped session ${state.sessionId}`
-    );
-    cleanupSessionRefs(repoRoot, state.sessionId);
-    await deleteSessionState(repoRoot, tool, state.sessionId);
-    removed++;
+    try {
+      await acquireLock3(repoRoot, tool, state.sessionId, 1, 0);
+    } catch {
+      appendLog(
+        "info",
+        `git-traces: leaving session ${state.sessionId} (lock held \u2014 still active)`
+      );
+      continue;
+    }
+    try {
+      appendLog(
+        "info",
+        `git-traces: cleaning up stale scoped session ${state.sessionId}`
+      );
+      cleanupSessionRefs(repoRoot, state.sessionId);
+      await deleteSessionState(repoRoot, tool, state.sessionId);
+      removed++;
+    } finally {
+      await releaseLock3(repoRoot, tool, state.sessionId);
+    }
   }
   return removed;
 }
@@ -15321,16 +14269,34 @@ async function processSessionStartRepo(repo, tool, sessionId) {
     );
     return "skipped";
   }
-  await acquireLock3(repoRoot, tool);
+  let acquired = false;
   try {
+    await acquireLock3(repoRoot, tool, sessionId);
+    acquired = true;
     const staleLegacy = await readSessionState(repoRoot, tool);
     if (staleLegacy && staleLegacy.sessionId !== sessionId) {
-      appendLog(
-        "info",
-        `git-traces: cleaning up stale session ${staleLegacy.sessionId} (repo=${repoRoot})`
-      );
-      cleanupSessionRefs(repoRoot, staleLegacy.sessionId);
-      await deleteSessionState(repoRoot, tool);
+      let acquiredLegacy = false;
+      try {
+        await acquireLock3(repoRoot, tool, staleLegacy.sessionId, 1, 0);
+        acquiredLegacy = true;
+      } catch {
+        appendLog(
+          "info",
+          `git-traces: leaving legacy session ${staleLegacy.sessionId} (lock held \u2014 still active)`
+        );
+      }
+      if (acquiredLegacy) {
+        try {
+          appendLog(
+            "info",
+            `git-traces: cleaning up stale session ${staleLegacy.sessionId} (repo=${repoRoot})`
+          );
+          cleanupSessionRefs(repoRoot, staleLegacy.sessionId);
+          await deleteSessionState(repoRoot, tool);
+        } finally {
+          await releaseLock3(repoRoot, tool, staleLegacy.sessionId);
+        }
+      }
     }
     const staleCount = await cleanupStaleScopedSessionStates(
       repoRoot,
@@ -15352,7 +14318,7 @@ async function processSessionStartRepo(repo, tool, sessionId) {
     );
     return "failed";
   } finally {
-    await releaseLock3(repoRoot, tool);
+    if (acquired) await releaseLock3(repoRoot, tool, sessionId);
   }
 }
 async function handleSessionStart(payload, tool) {
@@ -15374,6 +14340,10 @@ async function handleSessionStart(payload, tool) {
     appendLog("warn", "git-traces: no session_id in payload, skipping");
     return;
   }
+  const reaped = await sweepStaleLockFiles();
+  if (reaped > 0) {
+    appendLog("info", `git-traces: reaped ${reaped} stale lock file(s)`);
+  }
   const repos = await loadConfiguredRepos();
   let initialized = 0;
   let skipped = 0;
@@ -15453,9 +14423,11 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
     );
     return "skipped";
   }
-  await acquireLock3(repoRoot, tool);
   let state = null;
+  let acquired = false;
   try {
+    await acquireLock3(repoRoot, tool, sessionId);
+    acquired = true;
     state = await readSessionState(repoRoot, tool, sessionId);
     if (!state) {
       appendLog(
@@ -15555,9 +14527,9 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
       );
       return "unchanged";
     }
-    const prefix = epochPrefix(state.epoch);
+    const prefix = epochPrefix2(state.epoch);
     const nextTurnCount = state.turnCount + 1;
-    const turnLabel = turnSuffix(nextTurnCount);
+    const turnLabel = turnSuffix2(nextTurnCount);
     const filename = `${prefix}-${turnLabel}-${recordedAt}.patch.gz`;
     if ((state.contributionId === null || !state.baselineUploaded) && !canUploadFile(filename, patchBuffer)) {
       appendLog(
@@ -15655,7 +14627,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
     }
     return "failed";
   } finally {
-    await releaseLock3(repoRoot, tool);
+    if (acquired) await releaseLock3(repoRoot, tool, sessionId);
   }
 }
 async function handleStop(payload, tool) {
@@ -15672,7 +14644,7 @@ async function handleStop(payload, tool) {
   if (sessionId) {
     const storedStates = await listSessionStatesForSession(tool, sessionId);
     for (const { state } of storedStates) {
-      const repo = repoByRoot.get(path18.resolve(state.repoRoot));
+      const repo = repoByRoot.get(path17.resolve(state.repoRoot));
       if (!repo) {
         missingConfig++;
         appendLog(
@@ -15708,8 +14680,10 @@ async function handleStop(payload, tool) {
   );
 }
 async function cleanupSessionStateForRepo(repoRoot, tool, sessionId) {
-  await acquireLock3(repoRoot, tool);
+  let acquired = false;
   try {
+    await acquireLock3(repoRoot, tool, sessionId);
+    acquired = true;
     const state = await readSessionState(repoRoot, tool, sessionId);
     if (!state) return "no-state";
     cleanupSessionRefs(repoRoot, state.sessionId);
@@ -15726,7 +14700,7 @@ async function cleanupSessionStateForRepo(repoRoot, tool, sessionId) {
     );
     return "failed";
   } finally {
-    await releaseLock3(repoRoot, tool);
+    if (acquired) await releaseLock3(repoRoot, tool, sessionId);
   }
 }
 async function handleSessionEnd(payload, tool) {
@@ -15739,7 +14713,7 @@ async function handleSessionEnd(payload, tool) {
   if (sessionId) {
     const states = await listSessionStatesForSession(tool, sessionId);
     for (const { state } of states) {
-      repoRoots.push(path18.resolve(state.repoRoot));
+      repoRoots.push(path17.resolve(state.repoRoot));
     }
   }
   if (repoRoots.length === 0 && cwd) {
@@ -15755,7 +14729,7 @@ async function handleSessionEnd(payload, tool) {
   let skipped = 0;
   let failed = 0;
   for (const repoRoot of repoRoots) {
-    const repo = repoByRoot.get(path18.resolve(repoRoot)) ?? (project && path18.resolve(project.repoRoot) === path18.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(
@@ -15806,7 +14780,7 @@ var WORKER_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_WORKER";
 var TOOL_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_TOOL";
 var FLOW_ID_ENV2 = "HILLCLIMB_GIT_TRACES_FLOW";
 function newFlowId2() {
-  return crypto5.randomBytes(3).toString("hex");
+  return crypto6.randomBytes(3).toString("hex");
 }
 var KNOWN_TOOLS = /* @__PURE__ */ new Set([
   "claude",
@@ -16092,15 +15066,15 @@ ${stack}` : ""}`
 }
 
 // src/outputs/zip.ts
-import fs15 from "fs";
-import path20 from "path";
+import fs17 from "fs";
+import path19 from "path";
 import archiver2 from "archiver";
 
 // src/outputs/downloads.ts
 import { execSync as execSync2 } from "child_process";
-import fs14 from "fs";
+import fs16 from "fs";
 import os9 from "os";
-import path19 from "path";
+import path18 from "path";
 function getDownloadsFolder() {
   const home = os9.homedir();
   if (process.platform === "linux") {
@@ -16109,12 +15083,12 @@ function getDownloadsFolder() {
         encoding: "utf-8",
         timeout: 3e3
       }).trim();
-      if (xdgDir && fs14.existsSync(xdgDir)) return xdgDir;
+      if (xdgDir && fs16.existsSync(xdgDir)) return xdgDir;
     } catch {
     }
   }
-  const downloads = path19.join(home, "Downloads");
-  if (fs14.existsSync(downloads)) return downloads;
+  const downloads = path18.join(home, "Downloads");
+  if (fs16.existsSync(downloads)) return downloads;
   return home;
 }
 
@@ -16123,11 +15097,11 @@ function sanitizeFilename(name) {
   return name.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function getUniqueFilename(dir, base, ext) {
-  let candidate = path20.join(dir, `${base}${ext}`);
-  if (!fs15.existsSync(candidate)) return candidate;
+  let candidate = path19.join(dir, `${base}${ext}`);
+  if (!fs17.existsSync(candidate)) return candidate;
   let i = 1;
-  while (fs15.existsSync(candidate)) {
-    candidate = path20.join(dir, `${base}-${i}${ext}`);
+  while (fs17.existsSync(candidate)) {
+    candidate = path19.join(dir, `${base}-${i}${ext}`);
     i++;
   }
   return candidate;
@@ -16137,13 +15111,13 @@ var ZipOutput = class {
   label = "Save as .zip to Downloads";
   async emit(group, options) {
     const downloadsDir = getDownloadsFolder();
-    const repoName = sanitizeFilename(path20.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 = fs15.createWriteStream(outputPath);
+    const output = fs17.createWriteStream(outputPath);
     const archive = archiver2("zip", { zlib: { level: 6 } });
     const done = new Promise((resolve, reject) => {
       output.on("close", resolve);
@@ -16337,15 +15311,15 @@ async function confirmExport(group, output) {
 }
 
 // src/sources/claude.ts
-import fs16 from "fs";
+import fs18 from "fs";
 import os10 from "os";
-import path21 from "path";
+import path20 from "path";
 import readline2 from "readline";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["tool-results"]);
 async function resolveRepoPath(projectDir) {
-  const indexPath = path21.join(projectDir, "sessions-index.json");
+  const indexPath = path20.join(projectDir, "sessions-index.json");
   try {
-    const raw = await fs16.promises.readFile(indexPath, "utf-8");
+    const raw = await fs18.promises.readFile(indexPath, "utf-8");
     const data = JSON.parse(raw);
     if (data.originalPath && typeof data.originalPath === "string") {
       return data.originalPath;
@@ -16353,12 +15327,12 @@ async function resolveRepoPath(projectDir) {
   } catch {
   }
   const cwdCounts = /* @__PURE__ */ new Map();
-  const entries = await fs16.promises.readdir(projectDir, {
+  const entries = await fs18.promises.readdir(projectDir, {
     withFileTypes: true
   });
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-    const cwd = await extractCwdFromJsonl(path21.join(projectDir, entry.name));
+    const cwd = await extractCwdFromJsonl(path20.join(projectDir, entry.name));
     if (cwd) {
       cwdCounts.set(cwd, (cwdCounts.get(cwd) ?? 0) + 1);
     }
@@ -16377,7 +15351,7 @@ async function resolveRepoPath(projectDir) {
   return null;
 }
 async function extractCwdFromJsonl(filePath) {
-  const stream = fs16.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs18.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -16399,12 +15373,12 @@ async function extractCwdFromJsonl(filePath) {
 async function collectFiles(dir, baseDir, sourceName, repoPath, results) {
   let entries;
   try {
-    entries = await fs16.promises.readdir(dir, { withFileTypes: true });
+    entries = await fs18.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path21.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);
@@ -16426,19 +15400,19 @@ function fallbackDecode(encodedName) {
 var ClaudeSource = class {
   name = "claude";
   async scan() {
-    const baseDir = path21.join(os10.homedir(), ".claude", "projects");
+    const baseDir = path20.join(os10.homedir(), ".claude", "projects");
     try {
-      await fs16.promises.access(baseDir);
+      await fs18.promises.access(baseDir);
     } catch {
       return [];
     }
-    const projectDirs = await fs16.promises.readdir(baseDir, {
+    const projectDirs = await fs18.promises.readdir(baseDir, {
       withFileTypes: true
     });
     const dirEntries = projectDirs.filter((d) => d.isDirectory());
     const resultArrays = await Promise.all(
       dirEntries.map(async (dir) => {
-        const projectPath = path21.join(baseDir, dir.name);
+        const projectPath = path20.join(baseDir, dir.name);
         const repoPath = await resolveRepoPath(projectPath) ?? fallbackDecode(dir.name);
         const files = [];
         await collectFiles(
@@ -16456,12 +15430,12 @@ var ClaudeSource = class {
 };
 
 // src/sources/codex.ts
-import fs17 from "fs";
+import fs19 from "fs";
 import os11 from "os";
-import path22 from "path";
+import path21 from "path";
 import readline3 from "readline";
 async function parseSessionMeta(filePath) {
-  const stream = fs17.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs19.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline3.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -16486,12 +15460,12 @@ async function findJsonlFiles(dir) {
   async function walk(d) {
     let entries;
     try {
-      entries = await fs17.promises.readdir(d, { withFileTypes: true });
+      entries = await fs19.promises.readdir(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path22.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")) {
@@ -16505,11 +15479,11 @@ async function findJsonlFiles(dir) {
 async function loadHistory(historyPath) {
   const map = /* @__PURE__ */ new Map();
   try {
-    await fs17.promises.access(historyPath);
+    await fs19.promises.access(historyPath);
   } catch {
     return map;
   }
-  const stream = fs17.createReadStream(historyPath, { encoding: "utf-8" });
+  const stream = fs19.createReadStream(historyPath, { encoding: "utf-8" });
   const rl = readline3.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -16536,14 +15510,14 @@ async function loadHistory(historyPath) {
 var CodexSource = class {
   name = "codex";
   async scan() {
-    const codexDir = path22.join(os11.homedir(), ".codex");
-    const sessionsDir = path22.join(codexDir, "sessions");
+    const codexDir = path21.join(os11.homedir(), ".codex");
+    const sessionsDir = path21.join(codexDir, "sessions");
     try {
-      await fs17.promises.access(sessionsDir);
+      await fs19.promises.access(sessionsDir);
     } catch {
       return [];
     }
-    const historyPath = path22.join(codexDir, "history.jsonl");
+    const historyPath = path21.join(codexDir, "history.jsonl");
     const [jsonlFiles, historyMap] = await Promise.all([
       findJsonlFiles(sessionsDir),
       loadHistory(historyPath)
@@ -16566,8 +15540,8 @@ var CodexSource = class {
       });
       const historyLines = historyMap.get(meta.sessionId);
       if (historyLines) {
-        const sessionDir = path22.relative(sessionsDir, path22.dirname(filePath));
-        const historyAbsPath = path22.join(
+        const sessionDir = path21.relative(sessionsDir, path21.dirname(filePath));
+        const historyAbsPath = path21.join(
           sessionsDir,
           sessionDir,
           `history-${meta.sessionId}.jsonl`
@@ -16587,18 +15561,18 @@ var CodexSource = class {
 };
 
 // src/sources/copilotChat.ts
-import fs18 from "fs";
+import fs20 from "fs";
 import os12 from "os";
-import path23 from "path";
+import path22 from "path";
 import { fileURLToPath } from "url";
 function vsCodeUserDirs() {
   const home = os12.homedir();
   const dirs = [
-    path23.join(home, "Library", "Application Support", "Code", "User"),
-    path23.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(path23.join(process.env.APPDATA, "Code", "User"));
+    dirs.push(path22.join(process.env.APPDATA, "Code", "User"));
   }
   return dirs;
 }
@@ -16613,7 +15587,7 @@ function uriToFsPath(uri) {
 async function readWorkspaceFolder(workspaceJsonPath) {
   let raw;
   try {
-    raw = await fs18.promises.readFile(workspaceJsonPath, "utf-8");
+    raw = await fs20.promises.readFile(workspaceJsonPath, "utf-8");
   } catch {
     return null;
   }
@@ -16635,10 +15609,10 @@ var CopilotChatSource = class {
   async scan() {
     const results = [];
     for (const userDir of vsCodeUserDirs()) {
-      const workspaceStorage = path23.join(userDir, "workspaceStorage");
+      const workspaceStorage = path22.join(userDir, "workspaceStorage");
       let hashDirs;
       try {
-        hashDirs = await fs18.promises.readdir(workspaceStorage, {
+        hashDirs = await fs20.promises.readdir(workspaceStorage, {
           withFileTypes: true
         });
       } catch {
@@ -16646,22 +15620,22 @@ var CopilotChatSource = class {
       }
       for (const hash of hashDirs) {
         if (!hash.isDirectory()) continue;
-        const wsRoot = path23.join(workspaceStorage, hash.name);
-        const transcriptsDir = path23.join(
+        const wsRoot = path22.join(workspaceStorage, hash.name);
+        const transcriptsDir = path22.join(
           wsRoot,
           "GitHub.copilot-chat",
           "transcripts"
         );
         let transcriptEntries;
         try {
-          transcriptEntries = await fs18.promises.readdir(transcriptsDir, {
+          transcriptEntries = await fs20.promises.readdir(transcriptsDir, {
             withFileTypes: true
           });
         } catch {
           continue;
         }
         const repoPath = await readWorkspaceFolder(
-          path23.join(wsRoot, "workspace.json")
+          path22.join(wsRoot, "workspace.json")
         );
         if (!repoPath) continue;
         for (const entry of transcriptEntries) {
@@ -16669,7 +15643,7 @@ var CopilotChatSource = class {
           const sessionId = entry.name.slice(0, -".jsonl".length);
           results.push({
             sourceName: this.name,
-            absolutePath: path23.join(transcriptsDir, entry.name),
+            absolutePath: path22.join(transcriptsDir, entry.name),
             repoPath,
             metadata: { sessionId }
           });
@@ -16709,7 +15683,7 @@ function reportRedactionStats(noun, stats) {
 async function filterByTimeRange(group, range) {
   const results = await Promise.all(
     group.files.map(
-      (f) => fs19.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
+      (f) => fs21.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
     )
   );
   const filtered = [];
@@ -16736,10 +15710,10 @@ async function runInteractive() {
   s.start(`Scanning ${source.name} logs...`);
   const allFiles = await source.scan();
   const allGroups = await mergeByRepo(allFiles);
-  const repoRoot = path24.resolve(repo.root);
+  const repoRoot = path23.resolve(repo.root);
   const matching = allGroups.filter((g) => {
-    const resolved = path24.resolve(g.repoPath);
-    return resolved === repoRoot || resolved.startsWith(repoRoot + path24.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}.`);
@@ -16770,7 +15744,7 @@ async function runInteractive() {
     }
   }
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path24.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path23.join(repoRoot, n));
   const additionalFiles = await promptSecretFiles(envFileNames);
   const secretResult = await collectSecrets(
     repoRoot,