hillclimb 0.5.0 → 0.5.2

package/dist/cli.js

@@ -2,10 +2,11 @@
 
 // src/cli.ts
 import fs19 from "fs";
-import path23 from "path";
+import path24 from "path";
 import * as p6 from "@clack/prompts";
 
 // src/commands/init.ts
+import path7 from "path";
 import * as p3 from "@clack/prompts";
 
 // src/color.ts
@@ -124,67 +125,18 @@ function detectRepoRoot() {
   }
 }
 
-// src/gitignore.ts
+// src/identity.ts
 import fs2 from "fs";
 import path3 from "path";
-function toGitignorePattern(repoRoot, file) {
-  const rel = path3.relative(repoRoot, file);
-  if (!rel || rel.startsWith("..") || path3.isAbsolute(rel)) return null;
-  return `/${rel.split(path3.sep).join("/")}`;
-}
-function normalizePattern(pattern) {
-  return pattern.trim().replace(/\\/g, "/").replace(/^\/+/, "");
-}
-async function ensureGitignored(repoRoot, files) {
-  const gitignorePath = path3.join(repoRoot, ".gitignore");
-  const patterns = [
-    ...new Set(
-      files.map((file) => toGitignorePattern(repoRoot, file)).filter((pattern) => pattern !== null)
-    )
-  ];
-  let content = "";
-  let created = false;
-  try {
-    content = await fs2.promises.readFile(gitignorePath, "utf-8");
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-    created = true;
-  }
-  const existing = new Set(
-    content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map(normalizePattern)
-  );
-  const added = patterns.filter(
-    (pattern) => !existing.has(normalizePattern(pattern))
-  );
-  if (added.length === 0) {
-    return { path: gitignorePath, added: [], created: false, changed: false };
-  }
-  let next = content;
-  if (next && !next.endsWith("\n")) next += "\n";
-  if (next) next += "\n";
-  next += ["# Hillclimb hook files", ...added].join("\n");
-  next += "\n";
-  await fs2.promises.writeFile(gitignorePath, next);
-  return {
-    path: gitignorePath,
-    added,
-    created,
-    changed: true
-  };
-}
-
-// src/identity.ts
-import fs3 from "fs";
-import path4 from "path";
 function identityPath() {
-  return path4.join(configDir(), "identity.json");
+  return path3.join(configDir(), "identity.json");
 }
 function normalizeUrl(apiBaseUrl) {
   return apiBaseUrl.replace(/\/$/, "");
 }
 async function loadAllIdentities() {
   try {
-    const raw = await fs3.promises.readFile(identityPath(), "utf-8");
+    const raw = await fs2.promises.readFile(identityPath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.identities || typeof parsed.identities !== "object") {
       return { identities: {} };
@@ -199,12 +151,12 @@ async function loadIdentity(apiBaseUrl) {
   return file.identities[normalizeUrl(apiBaseUrl)] ?? null;
 }
 async function writeIdentityFile(file) {
-  await fs3.promises.mkdir(configDir(), { recursive: true, mode: 448 });
+  await fs2.promises.mkdir(configDir(), { recursive: true, mode: 448 });
   const tmp = `${identityPath()}.tmp`;
-  await fs3.promises.writeFile(tmp, JSON.stringify(file, null, 2), {
+  await fs2.promises.writeFile(tmp, JSON.stringify(file, null, 2), {
     mode: 384
   });
-  await fs3.promises.rename(tmp, identityPath());
+  await fs2.promises.rename(tmp, identityPath());
 }
 async function saveIdentity(identity) {
   const file = await loadAllIdentities();
@@ -242,8 +194,8 @@ function formatError(err) {
 }
 
 // src/platform/log.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs3 from "fs";
+import path4 from "path";
 var PT_TIME_ZONE = "America/Los_Angeles";
 function pacificParts(date) {
   const parts = new Intl.DateTimeFormat("en-US", {
@@ -294,10 +246,10 @@ function pacificDateString(date) {
   return `${p7.year}-${p7.month}-${p7.day}`;
 }
 function logsDir() {
-  return path5.join(configDir(), "logs");
+  return path4.join(configDir(), "logs");
 }
 function todayLogPath() {
-  return path5.join(logsDir(), `${pacificDateString(/* @__PURE__ */ new Date())}.log`);
+  return path4.join(logsDir(), `${pacificDateString(/* @__PURE__ */ new Date())}.log`);
 }
 var logPrefix = "";
 function setLogPrefix(prefix) {
@@ -308,8 +260,8 @@ function appendLog(level, message) {
   const line = `[${pacificTimestamp(/* @__PURE__ */ new Date())}] [${level}]${tag} ${message}
 `;
   try {
-    fs4.mkdirSync(logsDir(), { recursive: true, mode: 448 });
-    fs4.appendFileSync(todayLogPath(), line);
+    fs3.mkdirSync(logsDir(), { recursive: true, mode: 448 });
+    fs3.appendFileSync(todayLogPath(), line);
   } catch {
     process.stderr.write(`hillclimb:${tag} ${level}: ${message}
 `);
@@ -597,9 +549,61 @@ var PlatformClient = class {
 };
 
 // src/platform/hooks.ts
+import { execFileSync } from "child_process";
 import fs5 from "fs";
 import os2 from "os";
 import path6 from "path";
+
+// src/gitignore.ts
+import fs4 from "fs";
+import path5 from "path";
+function toGitignorePattern(repoRoot, file) {
+  const rel = path5.relative(repoRoot, file);
+  if (!rel || rel.startsWith("..") || path5.isAbsolute(rel)) return null;
+  return `/${rel.split(path5.sep).join("/")}`;
+}
+function normalizePattern(pattern) {
+  return pattern.trim().replace(/\\/g, "/").replace(/^\/+/, "");
+}
+async function ensureGitignored(repoRoot, files) {
+  const gitignorePath = path5.join(repoRoot, ".gitignore");
+  const patterns = [
+    ...new Set(
+      files.map((file) => toGitignorePattern(repoRoot, file)).filter((pattern) => pattern !== null)
+    )
+  ];
+  let content = "";
+  let created = false;
+  try {
+    content = await fs4.promises.readFile(gitignorePath, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    created = true;
+  }
+  const existing = new Set(
+    content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map(normalizePattern)
+  );
+  const added = patterns.filter(
+    (pattern) => !existing.has(normalizePattern(pattern))
+  );
+  if (added.length === 0) {
+    return { path: gitignorePath, added: [], created: false, changed: false };
+  }
+  let next = content;
+  if (next && !next.endsWith("\n")) next += "\n";
+  if (next) next += "\n";
+  next += ["# Hillclimb hook files", ...added].join("\n");
+  next += "\n";
+  await fs4.promises.writeFile(gitignorePath, next);
+  return {
+    path: gitignorePath,
+    added,
+    created,
+    changed: true
+  };
+}
+
+// src/platform/hooks.ts
 var HOOK_CMD = (sub) => `npx hillclimb@latest ${sub}`;
 var GIT_TRACES_CMD = (tool) => `npx hillclimb@latest git-traces --tool=${tool}`;
 var CLAUDE_SESSIONEND_UPLOAD_TIMEOUT_SECONDS = 30;
@@ -723,20 +727,41 @@ function copilotChatDetect() {
   return candidates.some(isDir);
 }
 function ensureHooks(settings) {
-  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks || typeof settings.hooks !== "object" || Array.isArray(settings.hooks)) {
+    settings.hooks = {};
+  }
   return settings.hooks;
 }
 function settingsPath(repoRoot, def) {
   return path6.join(repoRoot, def.settingsFile);
 }
-async function readJson(file) {
+async function readJson(file, options = {}) {
   try {
     const raw = await fs5.promises.readFile(file, "utf-8");
+    if (!raw.trim()) return {};
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
     return {};
   } catch (err) {
     if (err.code === "ENOENT") return {};
+    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);
+        appendLog(
+          "warn",
+          `hooks: backed up malformed JSON hook file ${file} to ${backup}`
+        );
+      } catch (backupErr) {
+        appendLog(
+          "warn",
+          `hooks: could not back up malformed JSON hook file ${file}: ${backupErr instanceof Error ? backupErr.message : String(backupErr)}`
+        );
+      }
+      return {};
+    }
+    if (err instanceof SyntaxError) return {};
     throw err;
   }
 }
@@ -1167,6 +1192,19 @@ function legacyBareGitTracesCommandsFor(command) {
     (legacy) => legacy.endsWith(" git-traces")
   );
 }
+function legacyBareUploadCommandsFor(command) {
+  const prefix = "npx hillclimb@latest ";
+  if (!command.startsWith(prefix)) return [];
+  const sub = command.slice(prefix.length);
+  if (!sub.startsWith("upload --tool=")) return [];
+  return [
+    "npx hillclimb@latest upload",
+    "npx hillclimb upload",
+    "hillclimb-extract upload",
+    "npx hillclimb-extract upload",
+    "npx @hillclimb/extract upload"
+  ];
+}
 function isHillclimbOwnedCommandFor(command, currentCommand) {
   if (command === currentCommand || legacyCommandsFor(currentCommand).includes(command)) {
     return true;
@@ -1182,7 +1220,7 @@ async function installHooksForTool(repoRoot, def) {
     const r = await opencodeInstall(file);
     return { settingsFile: file, ...r, changed: r.installed > 0 };
   }
-  const settings = await readJson(file);
+  const settings = await readJson(file, { repairMalformed: true });
   let installed = 0;
   let alreadyPresent = 0;
   let mutated = false;
@@ -1227,6 +1265,10 @@ async function checkHooksForTool(repoRoot, def) {
       missing.push(`${evt.eventName}:${evt.command}`);
     }
   }
+  if (def.tool === "codex" && missing.length === 0) {
+    const enabled = await areCodexHooksEnabled();
+    if (!enabled) missing.push("features.hooks");
+  }
   return { allInstalled: missing.length === 0, settingsFile: file, missing };
 }
 async function findLegacyGitTracesHookOwners(repoRoot, eventName) {
@@ -1250,9 +1292,57 @@ async function findLegacyGitTracesHookOwners(repoRoot, eventName) {
   }
   return owners;
 }
+async function findLegacyUploadHookOwners(repoRoot, eventName) {
+  if (!eventName) return [];
+  const owners = [];
+  for (const def of TOOLS) {
+    if (def.format === "opencode") continue;
+    const events = def.events.filter(
+      (evt) => evt.eventName === eventName && evt.command.startsWith("npx hillclimb@latest upload")
+    );
+    if (events.length === 0) continue;
+    const settings = await readJson(settingsPath(repoRoot, def));
+    const commands = new Set(commandsForEvent(settings, def.format, eventName));
+    if (events.some((evt) => {
+      const candidates = evt.command.includes("--tool=") ? legacyBareUploadCommandsFor(evt.command) : [evt.command, ...legacyCommandsFor(evt.command)];
+      return candidates.some((candidate) => commands.has(candidate));
+    })) {
+      owners.push(def.tool);
+    }
+  }
+  return owners;
+}
 function detectTools(repoRoot) {
   return TOOLS.filter((def) => def.detect(repoRoot));
 }
+function trackedHookFiles(repoRoot, files) {
+  const rels = files.map((file) => path6.relative(repoRoot, file)).filter((rel) => rel && !rel.startsWith("..") && !path6.isAbsolute(rel));
+  if (rels.length === 0) return [];
+  try {
+    const output = execFileSync("git", ["ls-files", "--", ...rels], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString("utf-8").trim();
+    if (!output) return [];
+    return output.split(/\r?\n/).map((rel) => path6.join(repoRoot, rel));
+  } catch {
+    return [];
+  }
+}
+async function ensureHookFilesIgnored(repoRoot, files) {
+  const ignored = await ensureGitignored(repoRoot, [
+    ...files,
+    ...files.map((file) => `${file}.malformed-*`)
+  ]);
+  const tracked = trackedHookFiles(repoRoot, files);
+  if (tracked.length > 0) {
+    appendLog(
+      "warn",
+      `hooks: hook files are already tracked by git and may be committed (${tracked.join(", ")})`
+    );
+  }
+  return { ...ignored, tracked };
+}
 async function installDetectedHooks(repoRoot) {
   const detected = detectTools(repoRoot);
   const results = [];
@@ -1280,6 +1370,20 @@ async function healHookForTool(repoRoot, tool) {
     };
   }
   const r = await installHooksForTool(repoRoot, def);
+  try {
+    const ignored = await ensureHookFilesIgnored(repoRoot, [r.settingsFile]);
+    if (ignored.changed) {
+      appendLog(
+        "info",
+        `self-heal: gitignored ${def.tool} hook file (${ignored.added.join(",")})`
+      );
+    }
+  } catch (err) {
+    appendLog(
+      "warn",
+      `self-heal: could not update .gitignore for ${def.tool} hook: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
   return {
     tool: def.tool,
     label: def.label,
@@ -1303,20 +1407,38 @@ async function checkAllHooks(repoRoot) {
   }
   return results;
 }
-var CODEX_CONFIG_PATH = path6.join(os2.homedir(), ".codex", "config.toml");
+function codexConfigPath() {
+  return process.env.HILLCLIMB_CODEX_CONFIG_PATH ?? path6.join(os2.homedir(), ".codex", "config.toml");
+}
+function codexHooksEnabledInConfig(content) {
+  const featuresMatch = content.match(/^\[features\]\s*$/m);
+  if (!featuresMatch || featuresMatch.index === void 0) return false;
+  const bodyStart = featuresMatch.index + featuresMatch[0].length;
+  const nextSectionOffset = content.slice(bodyStart).search(/\n\[[^\n]+\]\s*(?:\r?\n|$)/);
+  const bodyEnd = nextSectionOffset === -1 ? content.length : bodyStart + nextSectionOffset;
+  const body = content.slice(bodyStart, bodyEnd);
+  const hooksMatch = body.match(/^\s*hooks\s*=\s*(true|false)\s*(?:#.*)?$/im);
+  return hooksMatch?.[1]?.toLowerCase() === "true";
+}
+async function areCodexHooksEnabled() {
+  try {
+    const content = await fs5.promises.readFile(codexConfigPath(), "utf-8");
+    return codexHooksEnabledInConfig(content);
+  } catch {
+    return false;
+  }
+}
 async function ensureCodexHooksEnabled() {
   let content;
+  const configPath2 = codexConfigPath();
   try {
-    content = await fs5.promises.readFile(CODEX_CONFIG_PATH, "utf-8");
+    content = await fs5.promises.readFile(configPath2, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
-      await fs5.promises.mkdir(path6.dirname(CODEX_CONFIG_PATH), {
+      await fs5.promises.mkdir(path6.dirname(configPath2), {
         recursive: true
       });
-      await fs5.promises.writeFile(
-        CODEX_CONFIG_PATH,
-        "[features]\nhooks = true\n"
-      );
+      await fs5.promises.writeFile(configPath2, "[features]\nhooks = true\n");
       return true;
     }
     throw err;
@@ -1354,7 +1476,7 @@ hooks = true
 `;
   }
   if (content === original) return false;
-  await fs5.promises.writeFile(CODEX_CONFIG_PATH, content);
+  await fs5.promises.writeFile(configPath2, content);
   return true;
 }
 var CLAUDE_DEF = TOOLS[0];
@@ -1754,6 +1876,7 @@ async function runInit(args = []) {
     userId: bootstrap.session.userId,
     savedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
+  const autoUploadWarnings = [];
   try {
     const hookResults = await installDetectedHooks(repoRoot);
     if (hookResults.length === 0) {
@@ -1778,7 +1901,7 @@ async function runInit(args = []) {
         }
       }
       try {
-        const ignored = await ensureGitignored(
+        const ignored = await ensureHookFilesIgnored(
           repoRoot,
           hookResults.map((r) => r.settingsFile)
         );
@@ -1791,11 +1914,21 @@ async function runInit(args = []) {
             `${ignored.created ? "Created" : "Updated"} .gitignore for hook files`
           );
         }
+        if (ignored.tracked.length > 0) {
+          const tracked = ignored.tracked.map((file) => path7.relative(repoRoot, file)).join(", ");
+          autoUploadWarnings.push(
+            `Hook files are already tracked by git: ${tracked}`
+          );
+          p3.log.warn(
+            `Hook files are already tracked by git and may be committed: ${tracked}`
+          );
+        }
       } catch (err) {
         appendLog(
           "warn",
           `init: could not update .gitignore for hook files: ${formatError(err)}`
         );
+        autoUploadWarnings.push("Could not update .gitignore for hook files.");
         p3.log.warn(
           `Could not update .gitignore for hook files: ${err instanceof Error ? err.message : String(err)}`
         );
@@ -1812,6 +1945,9 @@ async function runInit(args = []) {
             "warn",
             `init: could not enable Codex hooks: ${formatError(err)}`
           );
+          autoUploadWarnings.push(
+            "Could not enable Codex hooks in config.toml."
+          );
           p3.log.warn(
             `Could not enable hooks in config.toml: ${err instanceof Error ? err.message : String(err)}`
           );
@@ -1831,7 +1967,7 @@ async function runInit(args = []) {
     `init: completed (project=${project.slug}, contributionType=${type.slug})`
   );
   p3.outro(
-    `Done. Your next coding session in this repo will upload automatically to ${project.name}.`
+    autoUploadWarnings.length > 0 ? `Configured ${project.name}, but auto-upload needs attention: ${autoUploadWarnings.join(" ")}` : `Done. Your next coding session in this repo will upload automatically to ${project.name}.`
   );
 }
 
@@ -2050,7 +2186,7 @@ async function runLogout(args = []) {
 }
 
 // src/commands/status.ts
-import path7 from "path";
+import path8 from "path";
 async function runStatus(args = []) {
   const debug = args.includes("--debug");
   header("status");
@@ -2068,7 +2204,7 @@ async function runStatus(args = []) {
     return;
   }
   const { repoRoot, config } = match;
-  const repoName = repo?.name ?? path7.basename(repoRoot);
+  const repoName = repo?.name ?? path8.basename(repoRoot);
   if (IS_TTY) {
     process.stdout.write(`  ${dim("Checking login...")}`);
   }
@@ -2162,7 +2298,7 @@ async function runStatus(args = []) {
   try {
     const hookStatuses = await checkAllHooks(repoRoot);
     for (const h of hookStatuses) {
-      const rel = path7.relative(repoRoot, h.settingsFile) || h.settingsFile;
+      const rel = path8.relative(repoRoot, h.settingsFile) || h.settingsFile;
       debugRow(
         `${h.label} hook:`,
         `${rel} ${dim(`(${h.installed ? "installed" : "missing"})`)}`
@@ -2179,14 +2315,16 @@ async function runStatus(args = []) {
 
 // src/commands/upload.ts
 import { spawn as spawn2 } from "child_process";
+import crypto3 from "crypto";
 import fs11 from "fs";
 import os6 from "os";
-import path14 from "path";
+import path15 from "path";
+import readline from "readline";
 
 // src/debug-logs.ts
 import crypto from "crypto";
 import fs9 from "fs";
-import path11 from "path";
+import path12 from "path";
 
 // src/hook-events.ts
 function classifyHookEvent(event) {
@@ -2205,6 +2343,41 @@ function classifyHookEvent(event) {
   }
 }
 
+// src/hook-payload.ts
+function resolveHookCwd(payload) {
+  return payload.cwd ?? payload.workspace_roots?.[0] ?? null;
+}
+function resolveHookSessionId(payload) {
+  return payload.session_id ?? payload.conversation_id ?? null;
+}
+function inferSourceToolFromPayload(payload) {
+  if (payload.tool) return payload.tool;
+  if (payload.cursor_version) return "cursor";
+  const transcriptPath = payload.transcript_path ?? "";
+  if (transcriptPath.includes(".claude/projects/")) return "claude";
+  if (transcriptPath.includes(".cursor/projects/")) return "cursor";
+  if (transcriptPath.includes("GitHub.copilot-chat")) return "copilot-chat";
+  if (transcriptPath.includes(".hillclimb/opencode-transcripts/")) {
+    return "opencode";
+  }
+  if (transcriptPath.includes(".codex/")) return "codex";
+  switch (payload.hook_event_name) {
+    case "session.idle":
+    case "session.deleted":
+    case "server.instance.disposed":
+      return "opencode";
+    default:
+      return null;
+  }
+}
+function fallbackSourceTool(payload) {
+  const inferred = inferSourceToolFromPayload(payload);
+  if (inferred) return inferred;
+  const eventKind = classifyHookEvent(payload.hook_event_name);
+  if (eventKind === "stop") return "codex";
+  return "claude";
+}
+
 // src/middleware/pattern-redact.ts
 import os3 from "os";
 import { Worker } from "worker_threads";
@@ -10692,7 +10865,7 @@ var middleware = [];
 
 // src/middleware/secrets.ts
 import fs7 from "fs";
-import path8 from "path";
+import path9 from "path";
 var KNOWN_NON_SECRETS = /* @__PURE__ */ new Set([
   "true",
   "false",
@@ -10847,7 +11020,7 @@ async function discoverEnvFiles(repoRoot) {
   const envFiles = [];
   for (const name of entries) {
     if (!name.startsWith(".env")) continue;
-    const filePath = path8.join(repoRoot, name);
+    const filePath = path9.join(repoRoot, name);
     try {
       const stat = await fs7.promises.stat(filePath);
       if (stat.isFile()) envFiles.push(name);
@@ -10872,7 +11045,7 @@ async function collectSecrets(repoRoot, envFiles, additionalFiles) {
     }
   }
   for (const filePath of additionalFiles) {
-    const resolved = path8.resolve(repoRoot, filePath);
+    const resolved = path9.resolve(repoRoot, filePath);
     sourceFiles.push(resolved);
     for (const value of await parseEnvFile(resolved)) {
       if (isUsableValue(value)) {
@@ -10902,16 +11075,16 @@ import archiver from "archiver";
 
 // src/outputs/archive.ts
 import os4 from "os";
-import path9 from "path";
+import path10 from "path";
 function getSourceBaseDir(sourceName) {
   const home = os4.homedir();
   switch (sourceName) {
     case "claude":
-      return path9.join(home, ".claude", "projects");
+      return path10.join(home, ".claude", "projects");
     case "codex":
-      return path9.join(home, ".codex", "sessions");
+      return path10.join(home, ".codex", "sessions");
     case "debug-logs":
-      return path9.join(configDir(), "logs");
+      return path10.join(configDir(), "logs");
     default:
       return home;
   }
@@ -10920,8 +11093,8 @@ 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) ? path9.relative(baseDir, file.absolutePath) : path9.basename(file.absolutePath);
-    const archivePath = path9.join(file.sourceName, relativePath);
+    const relativePath = file.absolutePath.startsWith(baseDir) ? path10.relative(baseDir, file.absolutePath) : path10.basename(file.absolutePath);
+    const archivePath = path10.join(file.sourceName, relativePath);
     if (file.content) {
       archive.append(file.content, { name: archivePath });
     } else {
@@ -11005,20 +11178,20 @@ var PlatformUploadOutput = class {
 
 // src/pipeline.ts
 import fs8 from "fs";
-import path10 from "path";
+import path11 from "path";
 function canonicalizePath(p7) {
-  let resolved = path10.resolve(p7);
-  if (resolved.endsWith(path10.sep) && resolved !== path10.sep) {
+  let resolved = path11.resolve(p7);
+  if (resolved.endsWith(path11.sep) && resolved !== path11.sep) {
     resolved = resolved.slice(0, -1);
   }
   return resolved;
 }
 function computeLabel(repoPath, allPaths) {
-  const segments = repoPath.split(path10.sep).filter(Boolean);
+  const segments = repoPath.split(path11.sep).filter(Boolean);
   for (let depth = 1; depth <= segments.length; depth++) {
     const label = segments.slice(-depth).join("/");
     const matches = allPaths.filter((p7) => {
-      const s = p7.split(path10.sep).filter(Boolean);
+      const s = p7.split(path11.sep).filter(Boolean);
       return s.slice(-depth).join("/") === label;
     });
     if (matches.length === 1) return label;
@@ -11096,7 +11269,7 @@ var DEFAULT_WAIT_MS = 6e4;
 var LOCK_RETRIES = 100;
 var LOCK_RETRY_DELAY_MS = 100;
 function stateDir() {
-  return process.env.HILLCLIMB_DEBUG_LOG_STATE_DIR ?? path11.join(configDir(), "debug-log-uploads");
+  return process.env.HILLCLIMB_DEBUG_LOG_STATE_DIR ?? path12.join(configDir(), "debug-log-uploads");
 }
 function waitMs() {
   const raw = process.env.HILLCLIMB_DEBUG_LOG_WAIT_MS;
@@ -11105,7 +11278,7 @@ function waitMs() {
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_WAIT_MS;
 }
 function stateFile(eventId) {
-  return path11.join(stateDir(), `${eventId}.json`);
+  return path12.join(stateDir(), `${eventId}.json`);
 }
 function lockFile(eventId) {
   return `${stateFile(eventId)}.lock`;
@@ -11130,10 +11303,10 @@ function toolLabel(tool) {
   return labels[tool] ?? tool;
 }
 function resolveCwd(payload) {
-  return payload.cwd ?? payload.workspace_roots?.[0] ?? null;
+  return resolveHookCwd(payload);
 }
 function resolveSessionId(payload) {
-  return payload.session_id ?? payload.conversation_id ?? null;
+  return resolveHookSessionId(payload);
 }
 function stringOrNull(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
@@ -11152,7 +11325,7 @@ function expectedKinds(tool, eventKind, payload) {
 async function transcriptFingerprint(payload) {
   const transcriptPath = stringOrNull(payload.transcript_path);
   if (!transcriptPath) return {};
-  const resolved = path11.resolve(transcriptPath);
+  const resolved = path12.resolve(transcriptPath);
   try {
     const stat = await fs9.promises.stat(resolved);
     return {
@@ -11191,13 +11364,10 @@ async function eventContext(tool, payload) {
     conversationId: stringOrNull(payload.conversation_id),
     turnId,
     eventNonce,
-    // Only per-turn stop events need the transcript to disambiguate (they
-    // often lack a turn id); sessionEnd is keyed by sessionId. Folding it in
-    // for sessionEnd would diverge the agent/git eventIds whenever the two
-    // hooks send different payloads — e.g. the opencode plugin passes
-    // transcript_path to the upload spawn but not the git-traces spawn,
-    // causing a 60s orphan wait and a duplicate debug-log upload.
-    ...eventKind === "stop" ? await transcriptFingerprint(payload) : {}
+    // Only stop events without stable turn IDs need the transcript to
+    // disambiguate. When a turn_id exists, including mutable transcript
+    // mtime/size can split agent+git completions for the same logical event.
+    ...eventKind === "stop" && !turnId ? await transcriptFingerprint(payload) : {}
   };
   const eventId = crypto.createHash("sha256").update(JSON.stringify(fingerprint)).digest("hex").slice(0, 32);
   return {
@@ -11268,7 +11438,7 @@ function initialState(ctx, now) {
     eventKind: ctx.eventKind,
     hookEventName: ctx.hookEventName,
     sessionId: ctx.sessionId,
-    logDate: path11.basename(todayLogPath(), ".log"),
+    logDate: path12.basename(todayLogPath(), ".log"),
     firstSeenAt: now.toISOString()
   };
 }
@@ -11330,7 +11500,7 @@ async function waitForExpectedKinds(ctx, state) {
 }
 async function buildMiddleware(repoRoot) {
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path11.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path12.join(repoRoot, n));
   const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
   const middleware2 = [];
   if (secretResult.values.size > 0) {
@@ -11376,7 +11546,7 @@ async function uploadDebugLog(ctx, state) {
   };
   const group = {
     repoPath: ctx.repoRoot,
-    label: path11.basename(ctx.repoRoot),
+    label: path12.basename(ctx.repoRoot),
     files: [sourceFile],
     sourceNames: [DEBUG_LOGS_SLUG],
     lastModified: now
@@ -11398,7 +11568,7 @@ async function uploadDebugLog(ctx, state) {
       `Tool: ${label}`,
       `Event: ${ctx.hookEventName ?? ctx.eventKind}`,
       `Repo: ${ctx.repoRoot}`,
-      `Log: ${path11.basename(logPath)}`,
+      `Log: ${path12.basename(logPath)}`,
       `Agent done: ${state.agentDoneAt ?? "<not observed>"}`,
       `Git done: ${state.gitDoneAt ?? "<not observed>"}`,
       `Uploaded: ${now.toISOString()}`
@@ -11415,7 +11585,7 @@ async function uploadDebugLog(ctx, state) {
     );
     appendLog(
       "info",
-      `debug-logs: uploaded ${path11.basename(logPath)} to project ${ctx.config.projectSlug} (${ctx.config.projectId}) as contribution ${contributionId}`
+      `debug-logs: uploaded ${path12.basename(logPath)} to project ${ctx.config.projectSlug} (${ctx.config.projectId}) as contribution ${contributionId}`
     );
     return contributionId;
   } catch (err) {
@@ -11468,7 +11638,7 @@ async function recordDebugLogCompletion(args) {
 }
 
 // src/normalizer/index.ts
-import path12 from "path";
+import path13 from "path";
 
 // src/normalizer/claude.ts
 function stringify(value) {
@@ -13166,14 +13336,20 @@ var NormalizeMiddleware = class {
         continue;
       const content = file.content ? file.content.toString("utf-8") : null;
       if (!content) continue;
-      const sessionId = file.metadata?.sessionId ?? (file.sourceName === "codex" ? void 0 : path12.basename(file.absolutePath, ".jsonl"));
+      const sessionId = file.metadata?.sessionId ?? (file.sourceName === "codex" ? void 0 : path13.basename(file.absolutePath, ".jsonl"));
       try {
         const trajectory = normalizeContent(
           file.sourceName,
           content,
           sessionId
         );
-        if (!trajectory) continue;
+        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,
@@ -13187,7 +13363,11 @@ var NormalizeMiddleware = class {
           metadata: { ...file.metadata, isAtif: true },
           content: Buffer.from(json, "utf-8")
         });
-      } catch {
+      } catch (err) {
+        appendLog(
+          "warn",
+          `normalize: failed for source=${file.sourceName} session=${sessionId ?? "<unknown>"} file=${file.absolutePath}: ${err instanceof Error ? err.message : String(err)}`
+        );
       }
     }
     return { ...group, files: newFiles };
@@ -13198,15 +13378,15 @@ var NormalizeMiddleware = class {
 import crypto2 from "crypto";
 import fs10 from "fs";
 import os5 from "os";
-import path13 from "path";
+import path14 from "path";
 var CURRENT_SCHEMA_VERSION2 = 1;
-var DEFAULT_STATE_DIR = path13.join(
+var DEFAULT_STATE_DIR = path14.join(
   os5.homedir(),
   ".hillclimb",
   "agent-uploads"
 );
-var LOCK_RETRIES2 = 120;
-var LOCK_RETRY_DELAY_MS2 = 500;
+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;
@@ -13223,9 +13403,26 @@ function stateTtlMs() {
     DEFAULT_STATE_TTL_MS
   );
 }
+function lockRetryDelayMs() {
+  return Math.max(
+    1,
+    readPositiveEnvMs(
+      "HILLCLIMB_UPLOAD_LOCK_RETRY_DELAY_MS",
+      DEFAULT_LOCK_RETRY_DELAY_MS
+    )
+  );
+}
+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(`${path13.resolve(repoRoot)}\0${tool}\0${sessionId}`).digest("hex").slice(0, 16);
-  return path13.join(stateDir2(), `${hash}.json`);
+  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`;
@@ -13258,7 +13455,7 @@ async function deleteUploadState(repoRoot, tool, sessionId) {
   } catch {
   }
 }
-async function acquireLock2(repoRoot, tool, sessionId, retries = LOCK_RETRIES2, delayMs = LOCK_RETRY_DELAY_MS2) {
+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 });
   for (let i = 0; i < retries; i++) {
@@ -13267,18 +13464,24 @@ async function acquireLock2(repoRoot, tool, sessionId, retries = LOCK_RETRIES2,
         lockPath,
         fs10.constants.O_CREAT | fs10.constants.O_EXCL | fs10.constants.O_WRONLY
       );
-      await fd.write(String(process.pid));
-      await fd.close();
+      try {
+        await fd.write(String(process.pid));
+      } finally {
+        await fd.close();
+      }
       return;
     } catch (err) {
       if (err.code === "EEXIST" && i < retries - 1) {
         await new Promise((r) => setTimeout(r, delayMs));
         continue;
       }
+      if (err.code === "EEXIST") break;
       throw err;
     }
   }
-  throw new Error(`Failed to acquire upload lock after ${retries} retries`);
+  throw new Error(
+    `Failed to acquire upload lock for ${tool} session ${sessionId} after ${retries} retries (${delayMs}ms delay, lock=${lockPath})`
+  );
 }
 async function releaseLock2(repoRoot, tool, sessionId) {
   try {
@@ -13303,7 +13506,7 @@ async function sweepStaleUploadStates(ttlMs = stateTtlMs(), now = Date.now()) {
   }
   for (const entry of entries) {
     if (!entry.isFile()) continue;
-    const file = path13.join(stateDir2(), entry.name);
+    const file = path14.join(stateDir2(), entry.name);
     try {
       const st = await fs10.promises.stat(file);
       if (now - st.mtimeMs > ttlMs) {
@@ -13329,6 +13532,9 @@ function sanitize2(value) {
 function formatEpochSeconds2(date) {
   return String(Math.floor(date.getTime() / 1e3));
 }
+function newFlowId() {
+  return crypto3.randomBytes(3).toString("hex");
+}
 function lineHasAssistant(line) {
   return line.includes('"type":"assistant"') || line.includes('"role":"assistant"') || line.includes('"type":"assistant.');
 }
@@ -13355,16 +13561,41 @@ async function hasAssistantMessage(transcriptPath) {
   }
   return false;
 }
-function resolveSourceTool(payload) {
-  if (payload.tool) return payload.tool;
-  if (payload.cursor_version) return "cursor";
-  if (payload.hook_event_name === "Stop") return "codex";
-  return "claude";
+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;
+  if (repoRoot) {
+    const owners = await findLegacyUploadHookOwners(
+      repoRoot,
+      payload.hook_event_name
+    );
+    if (owners.length === 1) {
+      appendLog("info", `upload: inferred legacy bare hook owner ${owners[0]}`);
+      return owners[0];
+    }
+    if (owners.length > 1) {
+      appendLog(
+        "warn",
+        `upload: legacy bare hook matched multiple tools (${owners.join(", ")}); skipping to avoid misattribution`
+      );
+      return null;
+    }
+  }
+  return fallbackSourceTool(payload);
 }
 function summarizePayload(payload) {
-  const sessionId = payload.session_id ?? payload.conversation_id ?? null;
+  const sessionId = resolveHookSessionId(payload);
   const turnId = payload.turn_id ?? null;
-  const cwd = payload.cwd ?? payload.workspace_roots?.[0] ?? null;
+  const cwd = resolveHookCwd(payload);
   return JSON.stringify({
     session_id: sessionId,
     turn_id: turnId,
@@ -13378,6 +13609,54 @@ function summarizePayload(payload) {
     cursor_version_present: !!payload.cursor_version
   });
 }
+async function codexSessionIdFromFile(filePath) {
+  const stream = fs11.createReadStream(filePath, { encoding: "utf-8" });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "session_meta") return obj.payload?.id ?? null;
+      } catch {
+        return null;
+      }
+      return null;
+    }
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+  return null;
+}
+async function findCodexTranscriptPath(sessionId) {
+  const sessionsDir = process.env.HILLCLIMB_CODEX_SESSIONS_DIR ?? path15.join(os6.homedir(), ".codex", "sessions");
+  const candidates = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await fs11.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path15.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl") && entry.name.includes(sessionId)) {
+        candidates.push(full);
+      }
+    }
+  }
+  await walk(sessionsDir);
+  candidates.sort();
+  for (const filePath of candidates) {
+    if (await codexSessionIdFromFile(filePath) === sessionId) {
+      return filePath;
+    }
+  }
+  return void 0;
+}
 async function selfHealHook(repoRoot, tool) {
   if (process.env.HILLCLIMB_SKIP_HOOK_SELF_HEAL === "1") return;
   try {
@@ -13397,11 +13676,11 @@ async function selfHealHook(repoRoot, tool) {
   }
 }
 function resolveCursorTranscriptPath(payload) {
-  const id = payload.conversation_id ?? payload.session_id;
+  const id = resolveHookSessionId(payload);
   const workspace = payload.workspace_roots?.[0];
   if (!id || !workspace) return void 0;
   const encoded = workspace.replace(/^\//, "").replace(/\//g, "-");
-  return path14.join(
+  return path15.join(
     os6.homedir(),
     ".cursor",
     "projects",
@@ -13411,22 +13690,31 @@ function resolveCursorTranscriptPath(payload) {
     `${id}.jsonl`
   );
 }
+async function resolveTranscriptPath(payload, sourceTool, sessionId) {
+  if (payload.transcript_path) return payload.transcript_path;
+  if (sourceTool === "cursor") return resolveCursorTranscriptPath(payload);
+  if (sourceTool === "codex") {
+    const resolved = await findCodexTranscriptPath(sessionId);
+    if (resolved) {
+      appendLog(
+        "info",
+        `[${sessionId}] resolved missing Codex transcript_path via ~/.codex/sessions: ${resolved}`
+      );
+    }
+    return resolved;
+  }
+  return void 0;
+}
 async function runUploadInner(payload) {
-  const sessionId = payload.session_id;
-  const transcriptPath = payload.transcript_path ?? resolveCursorTranscriptPath(payload);
-  const cwd = payload.cwd ?? payload.workspace_roots?.[0];
-  const sourceTool = resolveSourceTool(payload);
+  const sessionId = resolveHookSessionId(payload);
+  const cwd = resolveHookCwd(payload);
   const eventKind = classifyHookEvent(payload.hook_event_name);
-  appendLog(
-    "info",
-    `[${sessionId ?? "no-id"}] payload parsed (tool=${sourceTool}, cwd=${cwd ?? "?"}, event=${eventKind ?? "?"})`
-  );
-  if (!sessionId || !transcriptPath || !cwd) {
+  if (!sessionId || !cwd) {
     appendLog(
       "warn",
-      `Skipping upload: missing required hook fields (session_id=${!!sessionId}, transcript_path=${!!transcriptPath}, cwd=${!!cwd})`
+      `Skipping upload: missing required hook fields (session_id=${!!sessionId}, transcript_path=${!!payload.transcript_path}, cwd=${!!cwd})`
     );
-    return;
+    return false;
   }
   const match = await findProjectForCwd(cwd);
   if (!match) {
@@ -13434,11 +13722,33 @@ async function runUploadInner(payload) {
       "warn",
       `Skipping session ${sessionId}: no hillclimb config for cwd ${cwd}. Run \`npx hillclimb\` in the repo.`
     );
-    return;
+    return false;
   }
   const { repoRoot, config } = match;
+  const sourceTool = await resolveSourceTool(payload, repoRoot);
+  if (!sourceTool) {
+    payload.tool = "unknown";
+    return false;
+  }
+  payload.tool = sourceTool;
+  appendLog(
+    "info",
+    `[${sessionId}] payload parsed (tool=${sourceTool}, cwd=${cwd}, event=${eventKind ?? "?"})`
+  );
   await selfHealHook(repoRoot, sourceTool);
-  const transcriptResolved = path14.resolve(transcriptPath);
+  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 = path15.resolve(transcriptPath);
   try {
     const stat = await fs11.promises.stat(transcriptResolved);
     if (!stat.isFile()) {
@@ -13446,23 +13756,23 @@ async function runUploadInner(payload) {
         "warn",
         `Skipping session ${sessionId}: transcript_path is not a file: ${transcriptResolved}`
       );
-      return;
+      return false;
     }
   } catch (err) {
     appendLog(
       "warn",
       `Skipping session ${sessionId}: transcript_path not readable (${transcriptResolved}): ${err instanceof Error ? err.message : String(err)}`
     );
-    return;
+    return false;
   }
   if (!await hasAssistantMessage(transcriptResolved)) {
     appendLog(
       "info",
       `Skipping session ${sessionId}: transcript contains no assistant messages (nothing to upload).`
     );
-    return;
+    return false;
   }
-  await uploadSession({
+  return await uploadSession({
     sessionId,
     transcriptPath: transcriptResolved,
     repoRoot,
@@ -13474,14 +13784,16 @@ async function runUploadInner(payload) {
 async function uploadSession(args) {
   const { sessionId, transcriptPath, repoRoot, config, sourceTool, eventKind } = args;
   const isSessionEnd = eventKind === "sessionEnd";
-  await withUploadLock(repoRoot, sourceTool, sessionId, async () => {
+  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 && transcriptSize === prior.lastTranscriptSize) {
+    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" : ""})`
@@ -13489,7 +13801,7 @@ async function uploadSession(args) {
       if (isSessionEnd) {
         await deleteUploadState(repoRoot, sourceTool, sessionId);
       }
-      return;
+      return true;
     }
     const now = /* @__PURE__ */ new Date();
     const sourceFile = {
@@ -13499,13 +13811,13 @@ async function uploadSession(args) {
     };
     const group = {
       repoPath: repoRoot,
-      label: path14.basename(repoRoot),
+      label: path15.basename(repoRoot),
       files: [sourceFile],
       sourceNames: [sourceTool],
       lastModified: now
     };
     const envFileNames = await discoverEnvFiles(repoRoot);
-    const envFilePaths = envFileNames.map((n) => path14.join(repoRoot, n));
+    const envFilePaths = envFileNames.map((n) => path15.join(repoRoot, n));
     const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
     const mwChain = [];
     if (secretResult.values.size > 0) {
@@ -13519,7 +13831,7 @@ async function uploadSession(args) {
         "error",
         `Session ${sessionId} upload skipped: no saved login for ${config.apiBaseUrl}. Run \`npx hillclimb login\`.`
       );
-      return;
+      return false;
     }
     const client = new PlatformClient(
       config.apiBaseUrl,
@@ -13566,7 +13878,8 @@ Uploaded: ${now.toISOString()}`;
         uploadCount: prior?.uploadCount ?? 0,
         firstUploadedAt: prior?.firstUploadedAt ?? now.toISOString(),
         lastUploadedAt: prior?.lastUploadedAt ?? now.toISOString(),
-        lastTranscriptSize: prior?.lastTranscriptSize
+        lastTranscriptSize: prior?.lastTranscriptSize,
+        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)";
@@ -13585,13 +13898,13 @@ Uploaded: ${now.toISOString()}`;
           "error",
           `Session ${sessionId} upload failed: authentication expired. Re-run \`npx hillclimb\` in ${repoRoot}.`
         );
-        return;
+        return false;
       }
       appendLog(
         "error",
         `Session ${sessionId} upload failed: ${err instanceof Error ? err.message : String(err)}`
       );
-      return;
+      return false;
     }
     const next = {
       schemaVersion: CURRENT_SCHEMA_VERSION2,
@@ -13604,7 +13917,8 @@ Uploaded: ${now.toISOString()}`;
       uploadCount: seq,
       firstUploadedAt: prior?.firstUploadedAt ?? now.toISOString(),
       lastUploadedAt: now.toISOString(),
-      lastTranscriptSize: transcriptSize
+      lastTranscriptSize: transcriptSize,
+      lastTranscriptSha256: transcriptSha256
     };
     await writeUploadState(next);
     appendLog(
@@ -13618,10 +13932,12 @@ Uploaded: ${now.toISOString()}`;
         `[${sessionId}] session complete \u2014 contribution ${contributionId}, ${seq} file(s); local state cleared`
       );
     }
+    return true;
   });
 }
 var WORKER_ENV_FLAG = "HILLCLIMB_UPLOAD_WORKER";
 var TOOL_ENV_FLAG = "HILLCLIMB_UPLOAD_TOOL";
+var FLOW_ID_ENV = "HILLCLIMB_UPLOAD_FLOW";
 function parseToolArg(argv) {
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -13635,6 +13951,8 @@ async function runUpload() {
     await runUploadWorker();
     return;
   }
+  const flowId = newFlowId();
+  setLogPrefix(`[${flowId}]`);
   appendLog("info", `upload hook invoked (pid ${process.pid})`);
   let raw;
   try {
@@ -13661,7 +13979,8 @@ async function runUpload() {
   const toolArg = parseToolArg(process.argv.slice(2));
   const workerEnv = {
     ...process.env,
-    [WORKER_ENV_FLAG]: "1"
+    [WORKER_ENV_FLAG]: "1",
+    [FLOW_ID_ENV]: flowId
   };
   if (toolArg) workerEnv[TOOL_ENV_FLAG] = toolArg;
   try {
@@ -13688,6 +14007,7 @@ async function runUpload() {
   }
 }
 async function runUploadWorker() {
+  setLogPrefix(`[${process.env[FLOW_ID_ENV] ?? newFlowId()}]`);
   appendLog("info", `upload worker started (pid ${process.pid})`);
   let raw;
   try {
@@ -13716,19 +14036,22 @@ async function runUploadWorker() {
   const toolOverride = process.env[TOOL_ENV_FLAG];
   if (toolOverride) payload.tool = toolOverride;
   appendLog("info", `worker: payload summary: ${summarizePayload(payload)}`);
+  let completed = false;
   try {
-    await runUploadInner(payload);
+    completed = await runUploadInner(payload);
   } catch (err) {
     appendLog(
       "error",
       `worker: unexpected error: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
     );
   } finally {
-    await recordDebugLogCompletion({
-      kind: "agent",
-      tool: resolveSourceTool(payload),
-      payload
-    });
+    if (completed) {
+      await recordDebugLogCompletion({
+        kind: "agent",
+        tool: fallbackSourceTool(payload),
+        payload
+      });
+    }
     try {
       await sweepStaleUploadStates();
     } catch {
@@ -13738,17 +14061,17 @@ async function runUploadWorker() {
 
 // src/git-traces/index.ts
 import { spawn as spawn3 } from "child_process";
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 
 // src/git-traces/handlers.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import path17 from "path";
+import { execFileSync as execFileSync3 } from "child_process";
+import path18 from "path";
 
 // src/git-traces/git-ops.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import fs12 from "fs";
 import os7 from "os";
-import path15 from "path";
+import path16 from "path";
 import { gzipSync } from "zlib";
 var GIT_COMMAND_TIMEOUT_MS = 12e4;
 var EXEC_OPTS = {
@@ -13802,7 +14125,7 @@ function isGitTimeoutError(err) {
 }
 function gitBuffer(repoRoot, args, options = {}) {
   try {
-    return execFileSync("git", args, {
+    return execFileSync2("git", args, {
       cwd: repoRoot,
       ...options.env ? { env: options.env } : {},
       ...options.input !== void 0 ? { input: options.input } : {},
@@ -13911,7 +14234,7 @@ function removePathsFromIndex(repoRoot, env, paths) {
 function filterOversizedFilesFromTree(repoRoot, treeSha, options = {}) {
   const oversizedFiles = listOversizedTreeFiles(repoRoot, treeSha, options);
   if (oversizedFiles.length === 0) return treeSha;
-  const tmpIndex = path15.join(
+  const tmpIndex = path16.join(
     os7.tmpdir(),
     `hillclimb-filter-${Date.now()}-${process.pid}`
   );
@@ -13943,7 +14266,7 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
   for (const relPath of list.split("\0")) {
     if (!relPath) continue;
     try {
-      const stat = fs12.lstatSync(path15.join(repoRoot, relPath));
+      const stat = fs12.lstatSync(path16.join(repoRoot, relPath));
       if (stat.size > MAX_SNAPSHOT_FILE_BYTES) {
         recordOmittedSnapshotFile(omittedFiles, {
           path: relPath,
@@ -13958,7 +14281,7 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
     }
   }
   if (kept.length === 0) return null;
-  const tmpIndex = path15.join(
+  const tmpIndex = path16.join(
     os7.tmpdir(),
     `hillclimb-untracked-${Date.now()}-${process.pid}`
   );
@@ -13988,7 +14311,7 @@ function buildSnapshotTree(repoRoot, stashSha, options = {}) {
   const untrackedTree = buildUntrackedTree(repoRoot, options.omittedFiles);
   if (!untrackedTree || untrackedTree === EMPTY_TREE_SHA)
     return filteredTrackedTree;
-  const tmpIndex = path15.join(
+  const tmpIndex = path16.join(
     os7.tmpdir(),
     `hillclimb-index-${Date.now()}-${process.pid}`
   );
@@ -14030,7 +14353,7 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
   ]);
   const orphanRef = `refs/hillclimb/bundle/${sessionId}`;
   pinRef(repoRoot, orphanRef, orphanCommit);
-  const tmpFile = path15.join(
+  const tmpFile = path16.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
@@ -14229,9 +14552,9 @@ function parseCommitFiles(repoRoot, sha) {
         oldPath
       });
     } else {
-      const path24 = parts[parts.length - 1];
-      indexByPath.set(path24, files.length);
-      files.push({ path: path24, status, additions: 0, deletions: 0 });
+      const path25 = parts[parts.length - 1];
+      indexByPath.set(path25, files.length);
+      files.push({ path: path25, status, additions: 0, deletions: 0 });
     }
   }
   for (const line of numstat.split("\n")) {
@@ -14297,22 +14620,22 @@ function cleanupSessionRefs(repoRoot, sessionId) {
 }
 
 // src/git-traces/session-state.ts
-import crypto3 from "crypto";
+import crypto4 from "crypto";
 import fs13 from "fs";
 import os8 from "os";
-import path16 from "path";
+import path17 from "path";
 var CURRENT_SCHEMA_VERSION3 = 3;
-var DEFAULT_STATE_DIR2 = path16.join(os8.homedir(), ".hillclimb", "git-traces");
-var LOCK_RETRIES3 = 120;
-var LOCK_RETRY_DELAY_MS3 = 500;
+var DEFAULT_STATE_DIR2 = path17.join(os8.homedir(), ".hillclimb", "git-traces");
+var LOCK_RETRIES2 = 120;
+var LOCK_RETRY_DELAY_MS2 = 500;
 function stateDir3() {
   return process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? DEFAULT_STATE_DIR2;
 }
 function stateFileForRepo(repoRoot, tool, sessionId) {
-  const hash = crypto3.createHash("sha256").update(
-    sessionId ? `${path16.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path16.resolve(repoRoot)}\0${tool}`
+  const hash = crypto4.createHash("sha256").update(
+    sessionId ? `${path17.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path17.resolve(repoRoot)}\0${tool}`
   ).digest("hex").slice(0, 16);
-  return path16.join(stateDir3(), `${hash}.json`);
+  return path17.join(stateDir3(), `${hash}.json`);
 }
 function lockFileForRepo(repoRoot, tool) {
   return `${stateFileForRepo(repoRoot, tool)}.lock`;
@@ -14339,14 +14662,14 @@ async function listScopedSessionStates(repoRoot, tool) {
   const states = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const file = path16.join(stateDir3(), entry.name);
+    const file = path17.join(stateDir3(), entry.name);
     const state = await readStateFile(file);
     if (!state) continue;
     if (typeof state.repoRoot !== "string" || typeof state.sessionId !== "string") {
       continue;
     }
-    if (path16.resolve(state.repoRoot) !== path16.resolve(repoRoot)) continue;
-    if (path16.resolve(file) !== path16.resolve(stateFileForRepo(repoRoot, tool, state.sessionId))) {
+    if (path17.resolve(state.repoRoot) !== path17.resolve(repoRoot)) continue;
+    if (path17.resolve(file) !== path17.resolve(stateFileForRepo(repoRoot, tool, state.sessionId))) {
       continue;
     }
     let mtimeMs = 0;
@@ -14369,14 +14692,14 @@ async function listSessionStatesForSession(tool, sessionId) {
   const states = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const file = path16.join(stateDir3(), entry.name);
+    const file = path17.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 (path16.resolve(file) !== path16.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
+    if (path17.resolve(file) !== path17.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
       continue;
     }
     let mtimeMs = 0;
@@ -14432,7 +14755,7 @@ async function deleteSessionState(repoRoot, tool, sessionId) {
   }
   await deleteStateFile(stateFileForRepo(repoRoot, tool));
 }
-async function acquireLock3(repoRoot, tool, retries = LOCK_RETRIES3, delayMs = LOCK_RETRY_DELAY_MS3) {
+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 });
   for (let i = 0; i < retries; i++) {
@@ -14479,18 +14802,18 @@ var TOOL_LABELS = {
 async function loadConfiguredRepos() {
   const file = await loadProjects();
   return Object.entries(file.projects).map(([repoRoot, config]) => ({
-    repoRoot: path17.resolve(repoRoot),
+    repoRoot: path18.resolve(repoRoot),
     config
   })).sort((a, b) => a.repoRoot.localeCompare(b.repoRoot));
 }
 function repoLabel(repoRoot) {
-  return path17.basename(repoRoot) || repoRoot;
+  return path18.basename(repoRoot) || repoRoot;
 }
 function resolveCwd2(payload) {
-  return payload.cwd ?? payload.workspace_roots?.[0] ?? null;
+  return resolveHookCwd(payload);
 }
 function resolveSessionId2(payload) {
-  return payload.session_id ?? payload.conversation_id ?? null;
+  return resolveHookSessionId(payload);
 }
 function epochPrefix(epoch) {
   return `epoch-${String(epoch).padStart(3, "0")}`;
@@ -14506,7 +14829,7 @@ function captureHeadSha(cwd) {
   }
 }
 function execGit(cwd, args) {
-  return execFileSync2("git", args, {
+  return execFileSync3("git", args, {
     cwd,
     stdio: ["pipe", "pipe", "pipe"],
     timeout: 3e4,
@@ -14699,27 +15022,34 @@ async function createGitTracesContribution(params) {
   const epochSeconds = formatEpochSeconds3(now);
   const shortId = state.sessionId.slice(0, 12);
   const repoName = repoLabel(repoRoot);
-  const contribution = await client.createContribution(config.projectId, {
-    contributionTypeSlug: GIT_TRACES_SLUG,
-    title: `${toolLabel2} session ${shortId} \u2014 ${repoName} \u2014 ${epochSeconds}`,
-    body: `Session ID: ${state.sessionId}
+  let contributionId = state.contributionId;
+  if (!contributionId) {
+    const contribution = await client.createContribution(config.projectId, {
+      contributionTypeSlug: GIT_TRACES_SLUG,
+      title: `${toolLabel2} session ${shortId} \u2014 ${repoName} \u2014 ${epochSeconds}`,
+      body: `Session ID: ${state.sessionId}
 Tool: ${toolLabel2}
 Repo: ${repoRoot}
 Uploaded: ${now.toISOString()}`
-  });
+    });
+    contributionId = contribution.id;
+    state.contributionId = contributionId;
+    state.baselineUploaded = false;
+    await writeSessionState(state, tool);
+  }
   const uploaded = await uploadEpochBaselineArtifacts({
     client,
-    contributionId: contribution.id,
+    contributionId,
     epoch: 1,
     artifacts
   });
   if (!uploaded) return null;
-  await client.submitContribution(contribution.id);
+  await client.submitContribution(contributionId);
   appendLog(
     "info",
-    `git-traces: baseline uploaded (repo=${repoRoot}, project=${config.projectId}, contribution=${contribution.id}, epoch=1, bundleBytes=${artifacts.bundleBuffer.byteLength}, metadataBytes=${artifacts.metadataBuffer.byteLength})`
+    `git-traces: baseline uploaded (repo=${repoRoot}, project=${config.projectId}, contribution=${contributionId}, epoch=1, bundleBytes=${artifacts.bundleBuffer.byteLength}, metadataBytes=${artifacts.metadataBuffer.byteLength})`
   );
-  return contribution.id;
+  return contributionId;
 }
 async function uploadEpochBaseline(params) {
   const artifacts = buildEpochBaselineArtifacts(params);
@@ -14760,6 +15090,7 @@ async function initializeSession(repoRoot, tool, sessionId) {
     schemaVersion: CURRENT_SCHEMA_VERSION3,
     sessionId,
     contributionId: null,
+    baselineUploaded: false,
     baselineSha: frozen.baselineSha,
     baselineTreeSha: frozen.baselineTreeSha,
     baselineMetadata: frozen.baselineMetadata,
@@ -14920,6 +15251,7 @@ async function registerInitialContribution(params) {
   });
   if (!contributionId) return false;
   state.contributionId = contributionId;
+  state.baselineUploaded = true;
   state.baselineTreeSha = artifacts.baselineTreeSha;
   state.lastSnapshotTreeSha = artifacts.baselineTreeSha;
   await writeSessionState(state, tool);
@@ -14961,7 +15293,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
     if (currentHeadSha !== state.headSha) {
       const client2 = await loadRepoClient(repo);
       if (!client2) return "skipped";
-      if (state.contributionId === null) {
+      if (state.contributionId === null || !state.baselineUploaded) {
         const artifacts2 = buildInitialBaselineArtifactsForState(
           repoRoot,
           tool,
@@ -15044,7 +15376,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
     const nextTurnCount = state.turnCount + 1;
     const turnLabel = turnSuffix(nextTurnCount);
     const filename = `${prefix}-${turnLabel}-${recordedAt}.patch.gz`;
-    if (state.contributionId === null && !canUploadFile(filename, patchBuffer)) {
+    if ((state.contributionId === null || !state.baselineUploaded) && !canUploadFile(filename, patchBuffer)) {
       appendLog(
         "warn",
         `git-traces: first changed turn skipped before contribution creation (repo=${repoRoot}, project=${config.projectId}, reason=patch-too-large)`
@@ -15053,7 +15385,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
     }
     const client = await loadRepoClient(repo);
     if (!client) return "skipped";
-    if (state.contributionId === null) {
+    if (state.contributionId === null || !state.baselineUploaded) {
       const artifacts = buildInitialBaselineArtifactsForState(
         repoRoot,
         tool,
@@ -15118,6 +15450,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
           {
             ...state,
             contributionId: null,
+            baselineUploaded: false,
             lastSnapshotSha: state.baselineSha,
             lastSnapshotTreeSha: state.baselineTreeSha,
             turnCount: 0
@@ -15156,7 +15489,7 @@ async function handleStop(payload, tool) {
   if (sessionId) {
     const storedStates = await listSessionStatesForSession(tool, sessionId);
     for (const { state } of storedStates) {
-      const repo = repoByRoot.get(path17.resolve(state.repoRoot));
+      const repo = repoByRoot.get(path18.resolve(state.repoRoot));
       if (!repo) {
         missingConfig++;
         appendLog(
@@ -15218,21 +15551,62 @@ async function handleSessionEnd(payload, tool) {
   const sessionId = resolveSessionId2(payload);
   const project = cwd ? await findProjectForCwd(cwd) : null;
   const triggerRepo = project?.repoRoot ?? cwd ?? "<none>";
+  const recordedAt = Date.now();
   const repoRoots = [];
   if (sessionId) {
     const states = await listSessionStatesForSession(tool, sessionId);
     for (const { state } of states) {
-      repoRoots.push(path17.resolve(state.repoRoot));
+      repoRoots.push(path18.resolve(state.repoRoot));
     }
   }
   if (repoRoots.length === 0 && cwd) {
     repoRoots.push(project?.repoRoot ?? cwd);
   }
   if (repoRoots.length === 0) return;
+  const repos = await loadConfiguredRepos();
+  const repoByRoot = new Map(repos.map((repo) => [repo.repoRoot, repo]));
   let cleaned = 0;
   let noState = 0;
+  let uploaded = 0;
+  let unchanged = 0;
+  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);
+    if (!repo) {
+      skipped++;
+      appendLog(
+        "warn",
+        `git-traces: preserving SessionEnd state for repo ${repoRoot} (reason=missing-config)`
+      );
+      continue;
+    }
+    const finalOutcome = await processStopRepo(
+      repo,
+      tool,
+      sessionId,
+      recordedAt
+    );
+    if (finalOutcome === "uploaded") uploaded++;
+    else if (finalOutcome === "unchanged") unchanged++;
+    else if (finalOutcome === "skipped") {
+      skipped++;
+      appendLog(
+        "warn",
+        `git-traces: preserving SessionEnd state for repo ${repoRoot} after skipped final upload`
+      );
+      continue;
+    } else if (finalOutcome === "failed") {
+      failed++;
+      appendLog(
+        "warn",
+        `git-traces: preserving SessionEnd state for repo ${repoRoot} after failed final upload`
+      );
+      continue;
+    } else {
+      noState++;
+      continue;
+    }
     const outcome = await cleanupSessionStateForRepo(repoRoot, tool, sessionId);
     if (outcome === "cleaned") cleaned++;
     else if (outcome === "no-state") noState++;
@@ -15240,16 +15614,16 @@ async function handleSessionEnd(payload, tool) {
   }
   appendLog(
     "info",
-    `git-traces: SessionEnd summary (session=${sessionId ?? "<none>"}, tool=${tool}, triggerRepo=${triggerRepo}, states=${repoRoots.length}, cleaned=${cleaned}, noState=${noState}, failed=${failed})`
+    `git-traces: SessionEnd summary (session=${sessionId ?? "<none>"}, tool=${tool}, triggerRepo=${triggerRepo}, states=${repoRoots.length}, uploaded=${uploaded}, unchanged=${unchanged}, skipped=${skipped}, cleaned=${cleaned}, noState=${noState}, failed=${failed})`
   );
 }
 
 // src/git-traces/index.ts
 var WORKER_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_WORKER";
 var TOOL_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_TOOL";
-var FLOW_ID_ENV = "HILLCLIMB_GIT_TRACES_FLOW";
-function newFlowId() {
-  return crypto4.randomBytes(3).toString("hex");
+var FLOW_ID_ENV2 = "HILLCLIMB_GIT_TRACES_FLOW";
+function newFlowId2() {
+  return crypto5.randomBytes(3).toString("hex");
 }
 var KNOWN_TOOLS = /* @__PURE__ */ new Set([
   "claude",
@@ -15388,7 +15762,7 @@ async function runGitTraces() {
     await runGitTracesWorker();
     return;
   }
-  const flowId = newFlowId();
+  const flowId = newFlowId2();
   setLogPrefix(`[${flowId}]`);
   const toolArg = parseToolArg2(process.argv.slice(2));
   appendLog(
@@ -15431,7 +15805,7 @@ async function runGitTraces() {
           ...process.env,
           [WORKER_ENV_FLAG2]: "1",
           [TOOL_ENV_FLAG2]: tool,
-          [FLOW_ID_ENV]: flowId
+          [FLOW_ID_ENV2]: flowId
         }
       }
     );
@@ -15453,7 +15827,7 @@ async function runGitTraces() {
   }
 }
 async function runGitTracesWorker() {
-  setLogPrefix(`[${process.env[FLOW_ID_ENV] ?? newFlowId()}]`);
+  setLogPrefix(`[${process.env[FLOW_ID_ENV2] ?? newFlowId2()}]`);
   const tool = process.env[TOOL_ENV_FLAG2] ?? parseToolArg2(process.argv.slice(2)) ?? null;
   appendLog(
     "info",
@@ -15536,14 +15910,14 @@ ${stack}` : ""}`
 
 // src/outputs/zip.ts
 import fs15 from "fs";
-import path19 from "path";
+import path20 from "path";
 import archiver2 from "archiver";
 
 // src/outputs/downloads.ts
 import { execSync as execSync2 } from "child_process";
 import fs14 from "fs";
 import os9 from "os";
-import path18 from "path";
+import path19 from "path";
 function getDownloadsFolder() {
   const home = os9.homedir();
   if (process.platform === "linux") {
@@ -15556,7 +15930,7 @@ function getDownloadsFolder() {
     } catch {
     }
   }
-  const downloads = path18.join(home, "Downloads");
+  const downloads = path19.join(home, "Downloads");
   if (fs14.existsSync(downloads)) return downloads;
   return home;
 }
@@ -15566,11 +15940,11 @@ function sanitizeFilename(name) {
   return name.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function getUniqueFilename(dir, base, ext) {
-  let candidate = path19.join(dir, `${base}${ext}`);
+  let candidate = path20.join(dir, `${base}${ext}`);
   if (!fs15.existsSync(candidate)) return candidate;
   let i = 1;
   while (fs15.existsSync(candidate)) {
-    candidate = path19.join(dir, `${base}-${i}${ext}`);
+    candidate = path20.join(dir, `${base}-${i}${ext}`);
     i++;
   }
   return candidate;
@@ -15580,7 +15954,7 @@ var ZipOutput = class {
   label = "Save as .zip to Downloads";
   async emit(group, options) {
     const downloadsDir = getDownloadsFolder();
-    const repoName = sanitizeFilename(path19.basename(group.repoPath));
+    const repoName = sanitizeFilename(path20.basename(group.repoPath));
     const timeRange = options.timeRange;
     const rangePart = timeRange?.label ?? "all";
     const epochSeconds = Math.floor(Date.now() / 1e3);
@@ -15782,11 +16156,11 @@ async function confirmExport(group, output) {
 // src/sources/claude.ts
 import fs16 from "fs";
 import os10 from "os";
-import path20 from "path";
-import readline from "readline";
+import path21 from "path";
+import readline2 from "readline";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["tool-results"]);
 async function resolveRepoPath(projectDir) {
-  const indexPath = path20.join(projectDir, "sessions-index.json");
+  const indexPath = path21.join(projectDir, "sessions-index.json");
   try {
     const raw = await fs16.promises.readFile(indexPath, "utf-8");
     const data = JSON.parse(raw);
@@ -15801,7 +16175,7 @@ async function resolveRepoPath(projectDir) {
   });
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-    const cwd = await extractCwdFromJsonl(path20.join(projectDir, entry.name));
+    const cwd = await extractCwdFromJsonl(path21.join(projectDir, entry.name));
     if (cwd) {
       cwdCounts.set(cwd, (cwdCounts.get(cwd) ?? 0) + 1);
     }
@@ -15821,7 +16195,7 @@ async function resolveRepoPath(projectDir) {
 }
 async function extractCwdFromJsonl(filePath) {
   const stream = fs16.createReadStream(filePath, { encoding: "utf-8" });
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
       if (!line.trim()) continue;
@@ -15847,7 +16221,7 @@ async function collectFiles(dir, baseDir, sourceName, repoPath, results) {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path20.join(dir, entry.name);
+    const fullPath = path21.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
       await collectFiles(fullPath, baseDir, sourceName, repoPath, results);
@@ -15869,7 +16243,7 @@ function fallbackDecode(encodedName) {
 var ClaudeSource = class {
   name = "claude";
   async scan() {
-    const baseDir = path20.join(os10.homedir(), ".claude", "projects");
+    const baseDir = path21.join(os10.homedir(), ".claude", "projects");
     try {
       await fs16.promises.access(baseDir);
     } catch {
@@ -15881,7 +16255,7 @@ var ClaudeSource = class {
     const dirEntries = projectDirs.filter((d) => d.isDirectory());
     const resultArrays = await Promise.all(
       dirEntries.map(async (dir) => {
-        const projectPath = path20.join(baseDir, dir.name);
+        const projectPath = path21.join(baseDir, dir.name);
         const repoPath = await resolveRepoPath(projectPath) ?? fallbackDecode(dir.name);
         const files = [];
         await collectFiles(
@@ -15901,11 +16275,11 @@ var ClaudeSource = class {
 // src/sources/codex.ts
 import fs17 from "fs";
 import os11 from "os";
-import path21 from "path";
-import readline2 from "readline";
+import path22 from "path";
+import readline3 from "readline";
 async function parseSessionMeta(filePath) {
   const stream = fs17.createReadStream(filePath, { encoding: "utf-8" });
-  const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
+  const rl = readline3.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
       if (!line.trim()) continue;
@@ -15934,7 +16308,7 @@ async function findJsonlFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const full = path21.join(d, entry.name);
+      const full = path22.join(d, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -15953,7 +16327,7 @@ async function loadHistory(historyPath) {
     return map;
   }
   const stream = fs17.createReadStream(historyPath, { encoding: "utf-8" });
-  const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
+  const rl = readline3.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
       if (!line.trim()) continue;
@@ -15979,14 +16353,14 @@ async function loadHistory(historyPath) {
 var CodexSource = class {
   name = "codex";
   async scan() {
-    const codexDir = path21.join(os11.homedir(), ".codex");
-    const sessionsDir = path21.join(codexDir, "sessions");
+    const codexDir = path22.join(os11.homedir(), ".codex");
+    const sessionsDir = path22.join(codexDir, "sessions");
     try {
       await fs17.promises.access(sessionsDir);
     } catch {
       return [];
     }
-    const historyPath = path21.join(codexDir, "history.jsonl");
+    const historyPath = path22.join(codexDir, "history.jsonl");
     const [jsonlFiles, historyMap] = await Promise.all([
       findJsonlFiles(sessionsDir),
       loadHistory(historyPath)
@@ -16009,8 +16383,8 @@ var CodexSource = class {
       });
       const historyLines = historyMap.get(meta.sessionId);
       if (historyLines) {
-        const sessionDir = path21.relative(sessionsDir, path21.dirname(filePath));
-        const historyAbsPath = path21.join(
+        const sessionDir = path22.relative(sessionsDir, path22.dirname(filePath));
+        const historyAbsPath = path22.join(
           sessionsDir,
           sessionDir,
           `history-${meta.sessionId}.jsonl`
@@ -16032,16 +16406,16 @@ var CodexSource = class {
 // src/sources/copilotChat.ts
 import fs18 from "fs";
 import os12 from "os";
-import path22 from "path";
+import path23 from "path";
 import { fileURLToPath } from "url";
 function vsCodeUserDirs() {
   const home = os12.homedir();
   const dirs = [
-    path22.join(home, "Library", "Application Support", "Code", "User"),
-    path22.join(home, ".config", "Code", "User")
+    path23.join(home, "Library", "Application Support", "Code", "User"),
+    path23.join(home, ".config", "Code", "User")
   ];
   if (process.env.APPDATA) {
-    dirs.push(path22.join(process.env.APPDATA, "Code", "User"));
+    dirs.push(path23.join(process.env.APPDATA, "Code", "User"));
   }
   return dirs;
 }
@@ -16078,7 +16452,7 @@ var CopilotChatSource = class {
   async scan() {
     const results = [];
     for (const userDir of vsCodeUserDirs()) {
-      const workspaceStorage = path22.join(userDir, "workspaceStorage");
+      const workspaceStorage = path23.join(userDir, "workspaceStorage");
       let hashDirs;
       try {
         hashDirs = await fs18.promises.readdir(workspaceStorage, {
@@ -16089,8 +16463,8 @@ var CopilotChatSource = class {
       }
       for (const hash of hashDirs) {
         if (!hash.isDirectory()) continue;
-        const wsRoot = path22.join(workspaceStorage, hash.name);
-        const transcriptsDir = path22.join(
+        const wsRoot = path23.join(workspaceStorage, hash.name);
+        const transcriptsDir = path23.join(
           wsRoot,
           "GitHub.copilot-chat",
           "transcripts"
@@ -16104,7 +16478,7 @@ var CopilotChatSource = class {
           continue;
         }
         const repoPath = await readWorkspaceFolder(
-          path22.join(wsRoot, "workspace.json")
+          path23.join(wsRoot, "workspace.json")
         );
         if (!repoPath) continue;
         for (const entry of transcriptEntries) {
@@ -16112,7 +16486,7 @@ var CopilotChatSource = class {
           const sessionId = entry.name.slice(0, -".jsonl".length);
           results.push({
             sourceName: this.name,
-            absolutePath: path22.join(transcriptsDir, entry.name),
+            absolutePath: path23.join(transcriptsDir, entry.name),
             repoPath,
             metadata: { sessionId }
           });
@@ -16179,10 +16553,10 @@ async function runInteractive() {
   s.start(`Scanning ${source.name} logs...`);
   const allFiles = await source.scan();
   const allGroups = await mergeByRepo(allFiles);
-  const repoRoot = path23.resolve(repo.root);
+  const repoRoot = path24.resolve(repo.root);
   const matching = allGroups.filter((g) => {
-    const resolved = path23.resolve(g.repoPath);
-    return resolved === repoRoot || resolved.startsWith(repoRoot + path23.sep);
+    const resolved = path24.resolve(g.repoPath);
+    return resolved === repoRoot || resolved.startsWith(repoRoot + path24.sep);
   });
   if (matching.length === 0) {
     s.stop(`No ${source.name} logs found for ${repo.name}.`);
@@ -16213,7 +16587,7 @@ async function runInteractive() {
     }
   }
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path23.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path24.join(repoRoot, n));
   const additionalFiles = await promptSecretFiles(envFileNames);
   const secretResult = await collectSecrets(
     repoRoot,