hillclimb 0.4.4 → 0.5.1

package/dist/cli.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs18 from "fs";
-import path22 from "path";
+import fs19 from "fs";
+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;
@@ -617,6 +621,15 @@ var TOOLS = [
         command: HOOK_CMD("upload"),
         timeout: CLAUDE_SESSIONEND_UPLOAD_TIMEOUT_SECONDS
       },
+      // Per-turn transcript capture. SessionEnd is the clean one-shot
+      // upload, but it never fires for sessions that are killed or never
+      // cleanly closed (e.g. long-lived remote sessions), so those
+      // transcripts are lost entirely. Uploading on Stop captures them
+      // turn-by-turn. `--tool=claude` is required: resolveSourceTool()
+      // defaults a bare `upload` on a Stop event to Codex, and the explicit
+      // tool also keys the debug-log agent/git completion correlation to
+      // "claude" (see expectedKinds() in debug-logs.ts).
+      { eventName: "Stop", command: `${HOOK_CMD("upload")} --tool=claude` },
       { eventName: "SessionStart", command: GIT_TRACES_CMD("claude") },
       { eventName: "Stop", command: GIT_TRACES_CMD("claude") },
       { eventName: "SessionEnd", command: GIT_TRACES_CMD("claude") }
@@ -630,6 +643,10 @@ var TOOLS = [
     format: "cursor",
     events: [
       { eventName: "sessionEnd", command: HOOK_CMD("upload") },
+      // Per-turn capture, mirroring Claude. Cursor's stop payload carries a
+      // populated transcript_path (verified on Cursor 3.0.16); --tool=cursor
+      // is required so a bare Stop upload isn't misattributed to Codex.
+      { eventName: "stop", command: `${HOOK_CMD("upload")} --tool=cursor` },
       { eventName: "sessionStart", command: GIT_TRACES_CMD("cursor") },
       { eventName: "stop", command: GIT_TRACES_CMD("cursor") },
       { eventName: "sessionEnd", command: GIT_TRACES_CMD("cursor") }
@@ -710,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;
   }
 }
@@ -854,7 +892,7 @@ function copilotUninstallMatching(settings, eventName, predicate) {
   }
   return true;
 }
-var OPENCODE_PLUGIN_VERSION = 6;
+var OPENCODE_PLUGIN_VERSION = 7;
 var OPENCODE_PLUGIN_MARKER = `// HILLCLIMB_OPENCODE_PLUGIN_VERSION=${OPENCODE_PLUGIN_VERSION}`;
 var OPENCODE_PLUGIN_CONTENT = `${OPENCODE_PLUGIN_MARKER}
 // Auto-installed by \`npx hillclimb\`. Do not edit manually \u2014 re-running
@@ -983,12 +1021,29 @@ export const HillclimbPlugin = async ({ directory }) => ({
     }
 
     if (type === "session.idle" && sessionID) {
-      // Per-turn git-traces snapshot only. Transcript upload is deferred to
-      // session.deleted (user-ended) or server.instance.disposed (process exit)
-      // so a single session produces one contribution, not one per turn.
+      // Per-turn snapshot: upload the transcript-so-far AND take a git-traces
+      // snapshot. The CLI keeps this to one contribution per session (reuse),
+      // attaching the latest transcript on each turn, so this is one
+      // contribution per session, not per turn. Keep the buffer \u2014 it's dropped
+      // only on session.deleted / server.instance.disposed.
+      //
+      // Pass transcript_path to BOTH spawns: the debug-log eventId for a stop
+      // event folds in transcript_path, so diverging payloads would orphan the
+      // two completions and double-upload the debug log.
+      const transcriptPath = writeTranscript(sessionID);
+      if (transcriptPath) {
+        spawnHillclimb("upload", {
+          session_id: sessionID,
+          cwd,
+          transcript_path: transcriptPath,
+          hook_event_name: "session.idle",
+          tool: TOOL,
+        });
+      }
       spawnHillclimb("git-traces --tool=opencode", {
         session_id: sessionID,
         cwd,
+        transcript_path: transcriptPath || undefined,
         hook_event_name: "session.idle",
         tool: TOOL,
       });
@@ -1137,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;
@@ -1152,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;
@@ -1197,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) {
@@ -1220,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 = [];
@@ -1250,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,
@@ -1273,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;
@@ -1324,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];
@@ -1724,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) {
@@ -1748,7 +1901,7 @@ async function runInit(args = []) {
         }
       }
       try {
-        const ignored = await ensureGitignored(
+        const ignored = await ensureHookFilesIgnored(
           repoRoot,
           hookResults.map((r) => r.settingsFile)
         );
@@ -1761,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)}`
         );
@@ -1782,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)}`
           );
@@ -1801,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}.`
   );
 }
 
@@ -2020,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");
@@ -2038,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...")}`);
   }
@@ -2132,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"})`)}`
@@ -2149,14 +2315,67 @@ async function runStatus(args = []) {
 
 // src/commands/upload.ts
 import { spawn as spawn2 } from "child_process";
-import fs10 from "fs";
-import os5 from "os";
-import path13 from "path";
+import crypto3 from "crypto";
+import fs11 from "fs";
+import os6 from "os";
+import path15 from "path";
 
 // 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) {
+  switch (event) {
+    case "Stop":
+    case "stop":
+    case "session.idle":
+      return "stop";
+    case "SessionEnd":
+    case "sessionEnd":
+    case "session.deleted":
+    case "server.instance.disposed":
+      return "sessionEnd";
+    default:
+      return null;
+  }
+}
+
+// src/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";
@@ -10645,7 +10864,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",
@@ -10800,7 +11019,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);
@@ -10825,7 +11044,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)) {
@@ -10855,16 +11074,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;
   }
@@ -10873,8 +11092,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 {
@@ -10916,14 +11135,23 @@ var PlatformUploadOutput = class {
       contributionTitle,
       contributionBody,
       zipFilename,
-      autoSubmit
+      autoSubmit,
+      existingContributionId,
+      onContributionCreated
     } = this.opts;
-    const contribution = await client.createContribution(projectId, {
-      contributionTypeSlug,
-      title: contributionTitle,
-      body: contributionBody
-    });
-    const presigned = await client.createUpload(contribution.id, {
+    let contributionId;
+    if (existingContributionId) {
+      contributionId = existingContributionId;
+    } else {
+      const contribution = await client.createContribution(projectId, {
+        contributionTypeSlug,
+        title: contributionTitle,
+        body: contributionBody
+      });
+      contributionId = contribution.id;
+      if (onContributionCreated) await onContributionCreated(contributionId);
+    }
+    const presigned = await client.createUpload(contributionId, {
       originalFilename: zipFilename,
       mimeType: "application/zip",
       sizeBytes: buffer.byteLength
@@ -10939,30 +11167,30 @@ var PlatformUploadOutput = class {
     );
     appendLog("info", `PUT to presigned URL succeeded for ${zipFilename}`);
     if (autoSubmit) {
-      appendLog("info", `submitting contribution ${contribution.id}`);
-      await client.submitContribution(contribution.id);
-      appendLog("info", `contribution ${contribution.id} submitted`);
+      appendLog("info", `submitting contribution ${contributionId}`);
+      await client.submitContribution(contributionId);
+      appendLog("info", `contribution ${contributionId} submitted`);
     }
-    return contribution.id;
+    return contributionId;
   }
 };
 
 // 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;
@@ -11040,7 +11268,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;
@@ -11049,7 +11277,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`;
@@ -11073,26 +11301,11 @@ function toolLabel(tool) {
   };
   return labels[tool] ?? tool;
 }
-function classifyHookEvent(event) {
-  switch (event) {
-    case "Stop":
-    case "stop":
-    case "session.idle":
-      return "stop";
-    case "SessionEnd":
-    case "sessionEnd":
-    case "session.deleted":
-    case "server.instance.disposed":
-      return "sessionEnd";
-    default:
-      return null;
-  }
-}
 function resolveCwd(payload) {
-  return payload.cwd ?? payload.workspace_roots?.[0] ?? null;
+  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;
@@ -11100,7 +11313,7 @@ function stringOrNull(value) {
 function expectedKinds(tool, eventKind, payload) {
   if (eventKind === "stop") {
     return new Set(
-      tool === "codex" || tool === "copilot-chat" ? ["agent", "git"] : ["git"]
+      tool === "codex" || tool === "copilot-chat" || tool === "claude" || tool === "cursor" || tool === "opencode" ? ["agent", "git"] : ["git"]
     );
   }
   if (tool === "opencode" && !resolveSessionId(payload)) {
@@ -11111,7 +11324,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 {
@@ -11150,13 +11363,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 {
@@ -11227,7 +11437,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()
   };
 }
@@ -11289,7 +11499,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) {
@@ -11335,7 +11545,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
@@ -11357,7 +11567,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()}`
@@ -11374,7 +11584,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) {
@@ -11427,7 +11637,7 @@ async function recordDebugLogCompletion(args) {
 }
 
 // src/normalizer/index.ts
-import path12 from "path";
+import path13 from "path";
 
 // src/normalizer/claude.ts
 function stringify(value) {
@@ -13125,14 +13335,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,
@@ -13146,13 +13362,140 @@ 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 };
   }
 };
 
+// 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 LOCK_RETRIES2 = 120;
+var LOCK_RETRY_DELAY_MS2 = 500;
+var DEFAULT_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
+function stateDir2() {
+  return process.env.HILLCLIMB_UPLOAD_STATE_DIR ?? DEFAULT_STATE_DIR;
+}
+function readPositiveEnvMs(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0) return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function stateTtlMs() {
+  return readPositiveEnvMs(
+    "HILLCLIMB_UPLOAD_STATE_TTL_MS",
+    DEFAULT_STATE_TTL_MS
+  );
+}
+function stateFileFor(repoRoot, tool, sessionId) {
+  const hash = crypto2.createHash("sha256").update(`${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) {
+  try {
+    const raw = await fs10.promises.readFile(
+      stateFileFor(repoRoot, tool, sessionId),
+      "utf-8"
+    );
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION2) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeUploadState(state) {
+  const file = stateFileFor(state.repoRoot, state.tool, state.sessionId);
+  await fs10.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+  const tmp = `${file}.tmp`;
+  await fs10.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+    mode: 384
+  });
+  await fs10.promises.rename(tmp, file);
+}
+async function deleteUploadState(repoRoot, tool, sessionId) {
+  try {
+    await fs10.promises.unlink(stateFileFor(repoRoot, tool, sessionId));
+  } catch {
+  }
+}
+async function acquireLock2(repoRoot, tool, sessionId, retries = LOCK_RETRIES2, delayMs = LOCK_RETRY_DELAY_MS2) {
+  const lockPath = lockFileFor(repoRoot, tool, sessionId);
+  await fs10.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+  for (let i = 0; i < retries; i++) {
+    try {
+      const fd = await fs10.promises.open(
+        lockPath,
+        fs10.constants.O_CREAT | fs10.constants.O_EXCL | fs10.constants.O_WRONLY
+      );
+      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;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`Failed to acquire upload lock after ${retries} retries`);
+}
+async function releaseLock2(repoRoot, tool, sessionId) {
+  try {
+    await fs10.promises.unlink(lockFileFor(repoRoot, tool, sessionId));
+  } catch {
+  }
+}
+async function withUploadLock(repoRoot, tool, sessionId, fn) {
+  await acquireLock2(repoRoot, tool, sessionId);
+  try {
+    return await fn();
+  } finally {
+    await releaseLock2(repoRoot, tool, sessionId);
+  }
+}
+async function sweepStaleUploadStates(ttlMs = stateTtlMs(), now = Date.now()) {
+  let entries;
+  try {
+    entries = await fs10.promises.readdir(stateDir2(), { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const file = path14.join(stateDir2(), entry.name);
+    try {
+      const st = await fs10.promises.stat(file);
+      if (now - st.mtimeMs > ttlMs) {
+        await fs10.promises.unlink(file);
+      }
+    } catch {
+    }
+  }
+}
+
 // src/commands/upload.ts
 async function readStdin() {
   if (process.stdin.isTTY) return "";
@@ -13168,11 +13511,14 @@ 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.');
 }
 async function hasAssistantMessage(transcriptPath) {
-  const stream = fs10.createReadStream(transcriptPath, { encoding: "utf-8" });
+  const stream = fs11.createReadStream(transcriptPath, { encoding: "utf-8" });
   let buffer = "";
   try {
     for await (const chunk of stream) {
@@ -13194,16 +13540,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,
@@ -13236,12 +13607,12 @@ 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 path13.join(
-    os5.homedir(),
+  return path15.join(
+    os6.homedir(),
     ".cursor",
     "projects",
     encoded,
@@ -13251,14 +13622,10 @@ function resolveCursorTranscriptPath(payload) {
   );
 }
 async function runUploadInner(payload) {
-  const sessionId = payload.session_id;
+  const sessionId = resolveHookSessionId(payload);
   const transcriptPath = payload.transcript_path ?? resolveCursorTranscriptPath(payload);
-  const cwd = payload.cwd ?? payload.workspace_roots?.[0];
-  const sourceTool = resolveSourceTool(payload);
-  appendLog(
-    "info",
-    `[${sessionId ?? "no-id"}] payload parsed (tool=${sourceTool}, cwd=${cwd ?? "?"})`
-  );
+  const cwd = resolveHookCwd(payload);
+  const eventKind = classifyHookEvent(payload.hook_event_name);
   if (!sessionId || !transcriptPath || !cwd) {
     appendLog(
       "warn",
@@ -13275,10 +13642,20 @@ async function runUploadInner(payload) {
     return;
   }
   const { repoRoot, config } = match;
+  const sourceTool = await resolveSourceTool(payload, repoRoot);
+  if (!sourceTool) {
+    payload.tool = "unknown";
+    return;
+  }
+  payload.tool = sourceTool;
+  appendLog(
+    "info",
+    `[${sessionId}] payload parsed (tool=${sourceTool}, cwd=${cwd}, event=${eventKind ?? "?"})`
+  );
   await selfHealHook(repoRoot, sourceTool);
-  const transcriptResolved = path13.resolve(transcriptPath);
+  const transcriptResolved = path15.resolve(transcriptPath);
   try {
-    const stat = await fs10.promises.stat(transcriptResolved);
+    const stat = await fs11.promises.stat(transcriptResolved);
     if (!stat.isFile()) {
       appendLog(
         "warn",
@@ -13305,92 +13682,166 @@ async function runUploadInner(payload) {
     transcriptPath: transcriptResolved,
     repoRoot,
     config,
-    sourceTool
+    sourceTool,
+    eventKind
   });
 }
 async function uploadSession(args) {
-  const { sessionId, transcriptPath, repoRoot, config, sourceTool } = args;
-  const now = /* @__PURE__ */ new Date();
-  const sourceFile = {
-    sourceName: sourceTool,
-    absolutePath: transcriptPath,
-    repoPath: repoRoot
-  };
-  const group = {
-    repoPath: repoRoot,
-    label: path13.basename(repoRoot),
-    files: [sourceFile],
-    sourceNames: [sourceTool],
-    lastModified: now
-  };
-  const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path13.join(repoRoot, n));
-  const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
-  const mwChain = [];
-  if (secretResult.values.size > 0) {
-    mwChain.push(new RedactMiddleware(secretResult.values));
-  }
-  mwChain.push(new PatternRedactMiddleware());
-  mwChain.push(new NormalizeMiddleware());
-  const identity = await loadIdentity(config.apiBaseUrl);
-  if (!identity) {
-    appendLog(
-      "error",
-      `Session ${sessionId} upload skipped: no saved login for ${config.apiBaseUrl}. Run \`npx hillclimb login\`.`
+  const { sessionId, transcriptPath, repoRoot, config, sourceTool, eventKind } = args;
+  const isSessionEnd = eventKind === "sessionEnd";
+  await withUploadLock(repoRoot, sourceTool, sessionId, async () => {
+    const prior = await readUploadState(repoRoot, sourceTool, sessionId);
+    let transcriptSize;
+    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);
+      }
+      return;
+    }
+    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));
+    }
+    mwChain.push(new PatternRedactMiddleware());
+    mwChain.push(new NormalizeMiddleware());
+    const identity = await loadIdentity(config.apiBaseUrl);
+    if (!identity) {
+      appendLog(
+        "error",
+        `Session ${sessionId} upload skipped: no saved login for ${config.apiBaseUrl}. Run \`npx hillclimb login\`.`
+      );
+      return;
+    }
+    const client = new PlatformClient(
+      config.apiBaseUrl,
+      identity.sessionCookie
     );
-    return;
-  }
-  const client = new PlatformClient(config.apiBaseUrl, identity.sessionCookie);
-  const shortId = sessionId.slice(0, 12);
-  const toolLabels = {
-    cursor: "Cursor",
-    codex: "Codex",
-    claude: "Claude",
-    "copilot-chat": "GitHub Copilot Chat",
-    opencode: "opencode"
-  };
-  const toolLabel2 = toolLabels[sourceTool] ?? "Claude";
-  const epochSeconds = formatEpochSeconds2(now);
-  const title = `${toolLabel2} session ${shortId} \u2014 ${epochSeconds}`;
-  const body = `Session ID: ${sessionId}
+    const shortId = sessionId.slice(0, 12);
+    const toolLabels = {
+      cursor: "Cursor",
+      codex: "Codex",
+      claude: "Claude",
+      "copilot-chat": "GitHub Copilot Chat",
+      opencode: "opencode"
+    };
+    const toolLabel2 = toolLabels[sourceTool] ?? "Claude";
+    const epochSeconds = formatEpochSeconds2(now);
+    const seq = (prior?.uploadCount ?? 0) + 1;
+    const title = `${toolLabel2} session ${shortId} \u2014 ${epochSeconds}`;
+    const body = `Session ID: ${sessionId}
 Tool: ${toolLabel2}
 Repo: ${repoRoot}
 Uploaded: ${now.toISOString()}`;
-  const zipFilename = `${sourceTool}-${sanitize2(shortId)}-${epochSeconds}.zip`;
-  const output = new PlatformUploadOutput({
-    client,
-    projectId: config.projectId,
-    contributionTypeSlug: config.contributionTypeSlug,
-    contributionTitle: title,
-    contributionBody: body,
-    zipFilename,
-    autoSubmit: config.autoSubmit
-  });
-  appendLog("info", `[${sessionId}] starting pipeline`);
-  try {
-    const contributionId = await runPipeline(group, mwChain, output, {
-      selectedSources: [sourceTool]
+    const zipFilename = `${sourceTool}-${sanitize2(shortId)}-${epochSeconds}-${String(seq).padStart(3, "0")}.zip`;
+    const alreadySubmitted = prior?.submitted ?? false;
+    const submitThisUpload = config.autoSubmit && !alreadySubmitted;
+    const output = new PlatformUploadOutput({
+      client,
+      projectId: config.projectId,
+      contributionTypeSlug: config.contributionTypeSlug,
+      contributionTitle: title,
+      contributionBody: body,
+      zipFilename,
+      autoSubmit: submitThisUpload,
+      existingContributionId: prior?.contributionId ?? void 0,
+      // Persist the new contribution id before the file PUT so a failed
+      // upload can't make the next Stop create a second contribution.
+      onContributionCreated: (id) => writeUploadState({
+        schemaVersion: CURRENT_SCHEMA_VERSION2,
+        sessionId,
+        tool: sourceTool,
+        repoRoot,
+        projectId: config.projectId,
+        contributionId: id,
+        submitted: alreadySubmitted,
+        uploadCount: prior?.uploadCount ?? 0,
+        firstUploadedAt: prior?.firstUploadedAt ?? now.toISOString(),
+        lastUploadedAt: prior?.lastUploadedAt ?? now.toISOString(),
+        lastTranscriptSize: prior?.lastTranscriptSize,
+        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)";
     appendLog(
       "info",
-      `Uploaded session ${sessionId} to project ${config.projectSlug} (${config.projectId}) as contribution ${contributionId}`
+      `[${sessionId}] ${sourceTool} ${isSessionEnd ? "SessionEnd" : "Stop"} upload \u2192 ${reuseDesc}`
     );
-  } catch (err) {
-    if (err instanceof PlatformError && err.status === 401) {
+    let contributionId;
+    try {
+      contributionId = await runPipeline(group, mwChain, output, {
+        selectedSources: [sourceTool]
+      });
+    } catch (err) {
+      if (err instanceof PlatformError && err.status === 401) {
+        appendLog(
+          "error",
+          `Session ${sessionId} upload failed: authentication expired. Re-run \`npx hillclimb\` in ${repoRoot}.`
+        );
+        return;
+      }
       appendLog(
         "error",
-        `Session ${sessionId} upload failed: authentication expired. Re-run \`npx hillclimb\` in ${repoRoot}.`
+        `Session ${sessionId} upload failed: ${err instanceof Error ? err.message : String(err)}`
       );
       return;
     }
+    const next = {
+      schemaVersion: CURRENT_SCHEMA_VERSION2,
+      sessionId,
+      tool: sourceTool,
+      repoRoot,
+      projectId: config.projectId,
+      contributionId,
+      submitted: alreadySubmitted || submitThisUpload,
+      uploadCount: seq,
+      firstUploadedAt: prior?.firstUploadedAt ?? now.toISOString(),
+      lastUploadedAt: now.toISOString(),
+      lastTranscriptSize: transcriptSize,
+      lastTranscriptSha256: transcriptSha256
+    };
+    await writeUploadState(next);
     appendLog(
-      "error",
-      `Session ${sessionId} upload failed: ${err instanceof Error ? err.message : String(err)}`
+      "info",
+      `Uploaded session ${sessionId} to project ${config.projectSlug} (${config.projectId}) as contribution ${contributionId} (seq=${seq})`
     );
-  }
+    if (isSessionEnd) {
+      await deleteUploadState(repoRoot, sourceTool, sessionId);
+      appendLog(
+        "info",
+        `[${sessionId}] session complete \u2014 contribution ${contributionId}, ${seq} file(s); local state cleared`
+      );
+    }
+  });
 }
 var WORKER_ENV_FLAG = "HILLCLIMB_UPLOAD_WORKER";
 var TOOL_ENV_FLAG = "HILLCLIMB_UPLOAD_TOOL";
+var FLOW_ID_ENV = "HILLCLIMB_UPLOAD_FLOW";
 function parseToolArg(argv) {
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -13404,6 +13855,8 @@ async function runUpload() {
     await runUploadWorker();
     return;
   }
+  const flowId = newFlowId();
+  setLogPrefix(`[${flowId}]`);
   appendLog("info", `upload hook invoked (pid ${process.pid})`);
   let raw;
   try {
@@ -13430,7 +13883,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 {
@@ -13457,6 +13911,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 {
@@ -13495,25 +13950,29 @@ async function runUploadWorker() {
   } finally {
     await recordDebugLogCompletion({
       kind: "agent",
-      tool: resolveSourceTool(payload),
+      tool: fallbackSourceTool(payload),
       payload
     });
+    try {
+      await sweepStaleUploadStates();
+    } catch {
+    }
   }
 }
 
 // src/git-traces/index.ts
 import { spawn as spawn3 } from "child_process";
-import crypto3 from "crypto";
+import crypto5 from "crypto";
 
 // src/git-traces/handlers.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import path16 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 fs11 from "fs";
-import os6 from "os";
-import path14 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import fs12 from "fs";
+import os7 from "os";
+import path16 from "path";
 import { gzipSync } from "zlib";
 var GIT_COMMAND_TIMEOUT_MS = 12e4;
 var EXEC_OPTS = {
@@ -13567,7 +14026,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 } : {},
@@ -13676,8 +14135,8 @@ function removePathsFromIndex(repoRoot, env, paths) {
 function filterOversizedFilesFromTree(repoRoot, treeSha, options = {}) {
   const oversizedFiles = listOversizedTreeFiles(repoRoot, treeSha, options);
   if (oversizedFiles.length === 0) return treeSha;
-  const tmpIndex = path14.join(
-    os6.tmpdir(),
+  const tmpIndex = path16.join(
+    os7.tmpdir(),
     `hillclimb-filter-${Date.now()}-${process.pid}`
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -13691,7 +14150,7 @@ function filterOversizedFilesFromTree(repoRoot, treeSha, options = {}) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs11.unlinkSync(tmpIndex);
+      fs12.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -13708,7 +14167,7 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
   for (const relPath of list.split("\0")) {
     if (!relPath) continue;
     try {
-      const stat = fs11.lstatSync(path14.join(repoRoot, relPath));
+      const stat = fs12.lstatSync(path16.join(repoRoot, relPath));
       if (stat.size > MAX_SNAPSHOT_FILE_BYTES) {
         recordOmittedSnapshotFile(omittedFiles, {
           path: relPath,
@@ -13723,8 +14182,8 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
     }
   }
   if (kept.length === 0) return null;
-  const tmpIndex = path14.join(
-    os6.tmpdir(),
+  const tmpIndex = path16.join(
+    os7.tmpdir(),
     `hillclimb-untracked-${Date.now()}-${process.pid}`
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -13736,7 +14195,7 @@ function buildUntrackedTree(repoRoot, omittedFiles) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs11.unlinkSync(tmpIndex);
+      fs12.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -13753,8 +14212,8 @@ function buildSnapshotTree(repoRoot, stashSha, options = {}) {
   const untrackedTree = buildUntrackedTree(repoRoot, options.omittedFiles);
   if (!untrackedTree || untrackedTree === EMPTY_TREE_SHA)
     return filteredTrackedTree;
-  const tmpIndex = path14.join(
-    os6.tmpdir(),
+  const tmpIndex = path16.join(
+    os7.tmpdir(),
     `hillclimb-index-${Date.now()}-${process.pid}`
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -13781,7 +14240,7 @@ function buildSnapshotTree(repoRoot, stashSha, options = {}) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs11.unlinkSync(tmpIndex);
+      fs12.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -13795,16 +14254,19 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
   ]);
   const orphanRef = `refs/hillclimb/bundle/${sessionId}`;
   pinRef(repoRoot, orphanRef, orphanCommit);
-  const tmpFile = path14.join(
-    os6.tmpdir(),
-    `hillclimb-bundle-${Date.now()}.bundle`
+  const tmpFile = 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
+    // collide on the same `git bundle create` path and its `.lock`.
+    `hillclimb-bundle-${Date.now()}-${process.pid}.bundle`
   );
   try {
     git(repoRoot, ["bundle", "create", tmpFile, orphanRef]);
-    return fs11.readFileSync(tmpFile);
+    return fs12.readFileSync(tmpFile);
   } finally {
     try {
-      fs11.unlinkSync(tmpFile);
+      fs12.unlinkSync(tmpFile);
     } catch {
     }
     deleteRef(repoRoot, orphanRef);
@@ -13902,7 +14364,7 @@ function buildBaselineMetadata(repoRoot, sessionId, tool, baselineSha, cliVersio
       ...omittedFiles.length > 0 ? { omittedFiles } : {}
     },
     author: { name: authorName, email: authorEmail },
-    hostname: os6.hostname(),
+    hostname: os7.hostname(),
     cliVersion,
     commits
   };
@@ -13991,9 +14453,9 @@ function parseCommitFiles(repoRoot, sha) {
         oldPath
       });
     } else {
-      const path23 = parts[parts.length - 1];
-      indexByPath.set(path23, files.length);
-      files.push({ path: path23, status, additions: 0, deletions: 0 });
+      const 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")) {
@@ -14059,31 +14521,31 @@ function cleanupSessionRefs(repoRoot, sessionId) {
 }
 
 // src/git-traces/session-state.ts
-import crypto2 from "crypto";
-import fs12 from "fs";
-import os7 from "os";
-import path15 from "path";
-var CURRENT_SCHEMA_VERSION2 = 3;
-var DEFAULT_STATE_DIR = path15.join(os7.homedir(), ".hillclimb", "git-traces");
-var LOCK_RETRIES2 = 120;
-var LOCK_RETRY_DELAY_MS2 = 500;
-function stateDir2() {
-  return process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? DEFAULT_STATE_DIR;
+import crypto4 from "crypto";
+import fs13 from "fs";
+import os8 from "os";
+import path17 from "path";
+var CURRENT_SCHEMA_VERSION3 = 3;
+var DEFAULT_STATE_DIR2 = path17.join(os8.homedir(), ".hillclimb", "git-traces");
+var LOCK_RETRIES3 = 120;
+var LOCK_RETRY_DELAY_MS3 = 500;
+function stateDir3() {
+  return process.env.HILLCLIMB_GIT_TRACES_STATE_DIR ?? DEFAULT_STATE_DIR2;
 }
 function stateFileForRepo(repoRoot, tool, sessionId) {
-  const hash = crypto2.createHash("sha256").update(
-    sessionId ? `${path15.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path15.resolve(repoRoot)}\0${tool}`
+  const hash = crypto4.createHash("sha256").update(
+    sessionId ? `${path17.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path17.resolve(repoRoot)}\0${tool}`
   ).digest("hex").slice(0, 16);
-  return path15.join(stateDir2(), `${hash}.json`);
+  return path17.join(stateDir3(), `${hash}.json`);
 }
 function lockFileForRepo(repoRoot, tool) {
   return `${stateFileForRepo(repoRoot, tool)}.lock`;
 }
 async function readStateFile(file) {
   try {
-    const raw = await fs12.promises.readFile(file, "utf-8");
+    const raw = await fs13.promises.readFile(file, "utf-8");
     const parsed = JSON.parse(raw);
-    if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION2) {
+    if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION3) {
       return null;
     }
     return parsed;
@@ -14094,26 +14556,26 @@ async function readStateFile(file) {
 async function listScopedSessionStates(repoRoot, tool) {
   let entries;
   try {
-    entries = await fs12.promises.readdir(stateDir2(), { withFileTypes: true });
+    entries = await fs13.promises.readdir(stateDir3(), { withFileTypes: true });
   } catch {
     return [];
   }
   const states = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const file = path15.join(stateDir2(), entry.name);
+    const file = path17.join(stateDir3(), entry.name);
     const state = await readStateFile(file);
     if (!state) continue;
     if (typeof state.repoRoot !== "string" || typeof state.sessionId !== "string") {
       continue;
     }
-    if (path15.resolve(state.repoRoot) !== path15.resolve(repoRoot)) continue;
-    if (path15.resolve(file) !== path15.resolve(stateFileForRepo(repoRoot, tool, state.sessionId))) {
+    if (path17.resolve(state.repoRoot) !== path17.resolve(repoRoot)) continue;
+    if (path17.resolve(file) !== path17.resolve(stateFileForRepo(repoRoot, tool, state.sessionId))) {
       continue;
     }
     let mtimeMs = 0;
     try {
-      mtimeMs = (await fs12.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs13.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -14124,26 +14586,26 @@ async function listScopedSessionStates(repoRoot, tool) {
 async function listSessionStatesForSession(tool, sessionId) {
   let entries;
   try {
-    entries = await fs12.promises.readdir(stateDir2(), { withFileTypes: true });
+    entries = await fs13.promises.readdir(stateDir3(), { withFileTypes: true });
   } catch {
     return [];
   }
   const states = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const file = path15.join(stateDir2(), entry.name);
+    const file = 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 (path15.resolve(file) !== path15.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
+    if (path17.resolve(file) !== path17.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
       continue;
     }
     let mtimeMs = 0;
     try {
-      mtimeMs = (await fs12.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs13.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -14164,12 +14626,12 @@ async function readSessionState(repoRoot, tool, sessionId) {
 }
 async function writeSessionState(state, tool) {
   const file = stateFileForRepo(state.repoRoot, tool, state.sessionId);
-  await fs12.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+  await fs13.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   const tmp = `${file}.tmp`;
-  await fs12.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+  await fs13.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
     mode: 384
   });
-  await fs12.promises.rename(tmp, file);
+  await fs13.promises.rename(tmp, file);
   const legacyFile = stateFileForRepo(state.repoRoot, tool);
   const legacy = await readStateFile(legacyFile);
   if (legacy?.sessionId === state.sessionId) {
@@ -14178,7 +14640,7 @@ async function writeSessionState(state, tool) {
 }
 async function deleteStateFile(file) {
   try {
-    await fs12.promises.unlink(file);
+    await fs13.promises.unlink(file);
   } catch {
   }
 }
@@ -14194,14 +14656,14 @@ async function deleteSessionState(repoRoot, tool, sessionId) {
   }
   await deleteStateFile(stateFileForRepo(repoRoot, tool));
 }
-async function acquireLock2(repoRoot, tool, retries = LOCK_RETRIES2, delayMs = LOCK_RETRY_DELAY_MS2) {
+async function acquireLock3(repoRoot, tool, retries = LOCK_RETRIES3, delayMs = LOCK_RETRY_DELAY_MS3) {
   const lockPath = lockFileForRepo(repoRoot, tool);
-  await fs12.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
+  await fs13.promises.mkdir(stateDir3(), { recursive: true, mode: 448 });
   for (let i = 0; i < retries; i++) {
     try {
-      const fd = await fs12.promises.open(
+      const fd = await fs13.promises.open(
         lockPath,
-        fs12.constants.O_CREAT | fs12.constants.O_EXCL | fs12.constants.O_WRONLY
+        fs13.constants.O_CREAT | fs13.constants.O_EXCL | fs13.constants.O_WRONLY
       );
       await fd.write(String(process.pid));
       await fd.close();
@@ -14216,9 +14678,9 @@ async function acquireLock2(repoRoot, tool, retries = LOCK_RETRIES2, delayMs = L
   }
   throw new Error(`Failed to acquire lock after ${retries} retries`);
 }
-async function releaseLock2(repoRoot, tool) {
+async function releaseLock3(repoRoot, tool) {
   try {
-    await fs12.promises.unlink(lockFileForRepo(repoRoot, tool));
+    await fs13.promises.unlink(lockFileForRepo(repoRoot, tool));
   } catch {
   }
 }
@@ -14241,18 +14703,18 @@ var TOOL_LABELS = {
 async function loadConfiguredRepos() {
   const file = await loadProjects();
   return Object.entries(file.projects).map(([repoRoot, config]) => ({
-    repoRoot: path16.resolve(repoRoot),
+    repoRoot: path18.resolve(repoRoot),
     config
   })).sort((a, b) => a.repoRoot.localeCompare(b.repoRoot));
 }
 function repoLabel(repoRoot) {
-  return path16.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")}`;
@@ -14268,7 +14730,7 @@ function captureHeadSha(cwd) {
   }
 }
 function execGit(cwd, args) {
-  return execFileSync2("git", args, {
+  return execFileSync3("git", args, {
     cwd,
     stdio: ["pipe", "pipe", "pipe"],
     timeout: 3e4,
@@ -14461,27 +14923,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);
@@ -14519,9 +14988,10 @@ async function initializeSession(repoRoot, tool, sessionId) {
   });
   if (!frozen) return null;
   const state = {
-    schemaVersion: CURRENT_SCHEMA_VERSION2,
+    schemaVersion: CURRENT_SCHEMA_VERSION3,
     sessionId,
     contributionId: null,
+    baselineUploaded: false,
     baselineSha: frozen.baselineSha,
     baselineTreeSha: frozen.baselineTreeSha,
     baselineMetadata: frozen.baselineMetadata,
@@ -14569,7 +15039,7 @@ async function processSessionStartRepo(repo, tool, sessionId) {
     );
     return "skipped";
   }
-  await acquireLock2(repoRoot, tool);
+  await acquireLock3(repoRoot, tool);
   try {
     const staleLegacy = await readSessionState(repoRoot, tool);
     if (staleLegacy && staleLegacy.sessionId !== sessionId) {
@@ -14600,7 +15070,7 @@ async function processSessionStartRepo(repo, tool, sessionId) {
     );
     return "failed";
   } finally {
-    await releaseLock2(repoRoot, tool);
+    await releaseLock3(repoRoot, tool);
   }
 }
 async function handleSessionStart(payload, tool) {
@@ -14682,6 +15152,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);
@@ -14700,7 +15171,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
     );
     return "skipped";
   }
-  await acquireLock2(repoRoot, tool);
+  await acquireLock3(repoRoot, tool);
   let state = null;
   try {
     state = await readSessionState(repoRoot, tool, sessionId);
@@ -14723,7 +15194,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,
@@ -14806,7 +15277,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)`
@@ -14815,7 +15286,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,
@@ -14880,6 +15351,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
           {
             ...state,
             contributionId: null,
+            baselineUploaded: false,
             lastSnapshotSha: state.baselineSha,
             lastSnapshotTreeSha: state.baselineTreeSha,
             turnCount: 0
@@ -14901,7 +15373,7 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
     }
     return "failed";
   } finally {
-    await releaseLock2(repoRoot, tool);
+    await releaseLock3(repoRoot, tool);
   }
 }
 async function handleStop(payload, tool) {
@@ -14918,7 +15390,7 @@ async function handleStop(payload, tool) {
   if (sessionId) {
     const storedStates = await listSessionStatesForSession(tool, sessionId);
     for (const { state } of storedStates) {
-      const repo = repoByRoot.get(path16.resolve(state.repoRoot));
+      const repo = repoByRoot.get(path18.resolve(state.repoRoot));
       if (!repo) {
         missingConfig++;
         appendLog(
@@ -14954,7 +15426,7 @@ async function handleStop(payload, tool) {
   );
 }
 async function cleanupSessionStateForRepo(repoRoot, tool, sessionId) {
-  await acquireLock2(repoRoot, tool);
+  await acquireLock3(repoRoot, tool);
   try {
     const state = await readSessionState(repoRoot, tool, sessionId);
     if (!state) return "no-state";
@@ -14972,7 +15444,7 @@ async function cleanupSessionStateForRepo(repoRoot, tool, sessionId) {
     );
     return "failed";
   } finally {
-    await releaseLock2(repoRoot, tool);
+    await releaseLock3(repoRoot, tool);
   }
 }
 async function handleSessionEnd(payload, tool) {
@@ -14980,21 +15452,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(path16.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++;
@@ -15002,16 +15515,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 crypto3.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",
@@ -15150,7 +15663,7 @@ async function runGitTraces() {
     await runGitTracesWorker();
     return;
   }
-  const flowId = newFlowId();
+  const flowId = newFlowId2();
   setLogPrefix(`[${flowId}]`);
   const toolArg = parseToolArg2(process.argv.slice(2));
   appendLog(
@@ -15193,7 +15706,7 @@ async function runGitTraces() {
           ...process.env,
           [WORKER_ENV_FLAG2]: "1",
           [TOOL_ENV_FLAG2]: tool,
-          [FLOW_ID_ENV]: flowId
+          [FLOW_ID_ENV2]: flowId
         }
       }
     );
@@ -15215,7 +15728,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",
@@ -15297,29 +15810,29 @@ ${stack}` : ""}`
 }
 
 // src/outputs/zip.ts
-import fs14 from "fs";
-import path18 from "path";
+import fs15 from "fs";
+import path20 from "path";
 import archiver2 from "archiver";
 
 // src/outputs/downloads.ts
 import { execSync as execSync2 } from "child_process";
-import fs13 from "fs";
-import os8 from "os";
-import path17 from "path";
+import fs14 from "fs";
+import os9 from "os";
+import path19 from "path";
 function getDownloadsFolder() {
-  const home = os8.homedir();
+  const home = os9.homedir();
   if (process.platform === "linux") {
     try {
       const xdgDir = execSync2("xdg-user-dir DOWNLOAD", {
         encoding: "utf-8",
         timeout: 3e3
       }).trim();
-      if (xdgDir && fs13.existsSync(xdgDir)) return xdgDir;
+      if (xdgDir && fs14.existsSync(xdgDir)) return xdgDir;
     } catch {
     }
   }
-  const downloads = path17.join(home, "Downloads");
-  if (fs13.existsSync(downloads)) return downloads;
+  const downloads = path19.join(home, "Downloads");
+  if (fs14.existsSync(downloads)) return downloads;
   return home;
 }
 
@@ -15328,11 +15841,11 @@ function sanitizeFilename(name) {
   return name.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function getUniqueFilename(dir, base, ext) {
-  let candidate = path18.join(dir, `${base}${ext}`);
-  if (!fs14.existsSync(candidate)) return candidate;
+  let candidate = path20.join(dir, `${base}${ext}`);
+  if (!fs15.existsSync(candidate)) return candidate;
   let i = 1;
-  while (fs14.existsSync(candidate)) {
-    candidate = path18.join(dir, `${base}-${i}${ext}`);
+  while (fs15.existsSync(candidate)) {
+    candidate = path20.join(dir, `${base}-${i}${ext}`);
     i++;
   }
   return candidate;
@@ -15342,13 +15855,13 @@ var ZipOutput = class {
   label = "Save as .zip to Downloads";
   async emit(group, options) {
     const downloadsDir = getDownloadsFolder();
-    const repoName = sanitizeFilename(path18.basename(group.repoPath));
+    const repoName = sanitizeFilename(path20.basename(group.repoPath));
     const timeRange = options.timeRange;
     const rangePart = timeRange?.label ?? "all";
     const epochSeconds = Math.floor(Date.now() / 1e3);
     const baseName = `logs-${repoName}-${rangePart}-${epochSeconds}`;
     const outputPath = getUniqueFilename(downloadsDir, baseName, ".zip");
-    const output = fs14.createWriteStream(outputPath);
+    const output = fs15.createWriteStream(outputPath);
     const archive = archiver2("zip", { zlib: { level: 6 } });
     const done = new Promise((resolve, reject) => {
       output.on("close", resolve);
@@ -15542,15 +16055,15 @@ async function confirmExport(group, output) {
 }
 
 // src/sources/claude.ts
-import fs15 from "fs";
-import os9 from "os";
-import path19 from "path";
+import fs16 from "fs";
+import os10 from "os";
+import path21 from "path";
 import readline from "readline";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["tool-results"]);
 async function resolveRepoPath(projectDir) {
-  const indexPath = path19.join(projectDir, "sessions-index.json");
+  const indexPath = path21.join(projectDir, "sessions-index.json");
   try {
-    const raw = await fs15.promises.readFile(indexPath, "utf-8");
+    const raw = await fs16.promises.readFile(indexPath, "utf-8");
     const data = JSON.parse(raw);
     if (data.originalPath && typeof data.originalPath === "string") {
       return data.originalPath;
@@ -15558,12 +16071,12 @@ async function resolveRepoPath(projectDir) {
   } catch {
   }
   const cwdCounts = /* @__PURE__ */ new Map();
-  const entries = await fs15.promises.readdir(projectDir, {
+  const entries = await fs16.promises.readdir(projectDir, {
     withFileTypes: true
   });
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-    const cwd = await extractCwdFromJsonl(path19.join(projectDir, entry.name));
+    const cwd = await extractCwdFromJsonl(path21.join(projectDir, entry.name));
     if (cwd) {
       cwdCounts.set(cwd, (cwdCounts.get(cwd) ?? 0) + 1);
     }
@@ -15582,7 +16095,7 @@ async function resolveRepoPath(projectDir) {
   return null;
 }
 async function extractCwdFromJsonl(filePath) {
-  const stream = fs15.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs16.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -15604,12 +16117,12 @@ async function extractCwdFromJsonl(filePath) {
 async function collectFiles(dir, baseDir, sourceName, repoPath, results) {
   let entries;
   try {
-    entries = await fs15.promises.readdir(dir, { withFileTypes: true });
+    entries = await fs16.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path19.join(dir, entry.name);
+    const fullPath = path21.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
       await collectFiles(fullPath, baseDir, sourceName, repoPath, results);
@@ -15631,19 +16144,19 @@ function fallbackDecode(encodedName) {
 var ClaudeSource = class {
   name = "claude";
   async scan() {
-    const baseDir = path19.join(os9.homedir(), ".claude", "projects");
+    const baseDir = path21.join(os10.homedir(), ".claude", "projects");
     try {
-      await fs15.promises.access(baseDir);
+      await fs16.promises.access(baseDir);
     } catch {
       return [];
     }
-    const projectDirs = await fs15.promises.readdir(baseDir, {
+    const projectDirs = await fs16.promises.readdir(baseDir, {
       withFileTypes: true
     });
     const dirEntries = projectDirs.filter((d) => d.isDirectory());
     const resultArrays = await Promise.all(
       dirEntries.map(async (dir) => {
-        const projectPath = path19.join(baseDir, dir.name);
+        const projectPath = path21.join(baseDir, dir.name);
         const repoPath = await resolveRepoPath(projectPath) ?? fallbackDecode(dir.name);
         const files = [];
         await collectFiles(
@@ -15661,12 +16174,12 @@ var ClaudeSource = class {
 };
 
 // src/sources/codex.ts
-import fs16 from "fs";
-import os10 from "os";
-import path20 from "path";
+import fs17 from "fs";
+import os11 from "os";
+import path22 from "path";
 import readline2 from "readline";
 async function parseSessionMeta(filePath) {
-  const stream = fs16.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs17.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -15691,12 +16204,12 @@ async function findJsonlFiles(dir) {
   async function walk(d) {
     let entries;
     try {
-      entries = await fs16.promises.readdir(d, { withFileTypes: true });
+      entries = await fs17.promises.readdir(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path20.join(d, entry.name);
+      const full = path22.join(d, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -15710,11 +16223,11 @@ async function findJsonlFiles(dir) {
 async function loadHistory(historyPath) {
   const map = /* @__PURE__ */ new Map();
   try {
-    await fs16.promises.access(historyPath);
+    await fs17.promises.access(historyPath);
   } catch {
     return map;
   }
-  const stream = fs16.createReadStream(historyPath, { encoding: "utf-8" });
+  const stream = fs17.createReadStream(historyPath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -15741,14 +16254,14 @@ async function loadHistory(historyPath) {
 var CodexSource = class {
   name = "codex";
   async scan() {
-    const codexDir = path20.join(os10.homedir(), ".codex");
-    const sessionsDir = path20.join(codexDir, "sessions");
+    const codexDir = path22.join(os11.homedir(), ".codex");
+    const sessionsDir = path22.join(codexDir, "sessions");
     try {
-      await fs16.promises.access(sessionsDir);
+      await fs17.promises.access(sessionsDir);
     } catch {
       return [];
     }
-    const historyPath = path20.join(codexDir, "history.jsonl");
+    const historyPath = path22.join(codexDir, "history.jsonl");
     const [jsonlFiles, historyMap] = await Promise.all([
       findJsonlFiles(sessionsDir),
       loadHistory(historyPath)
@@ -15771,8 +16284,8 @@ var CodexSource = class {
       });
       const historyLines = historyMap.get(meta.sessionId);
       if (historyLines) {
-        const sessionDir = path20.relative(sessionsDir, path20.dirname(filePath));
-        const historyAbsPath = path20.join(
+        const sessionDir = path22.relative(sessionsDir, path22.dirname(filePath));
+        const historyAbsPath = path22.join(
           sessionsDir,
           sessionDir,
           `history-${meta.sessionId}.jsonl`
@@ -15792,18 +16305,18 @@ var CodexSource = class {
 };
 
 // src/sources/copilotChat.ts
-import fs17 from "fs";
-import os11 from "os";
-import path21 from "path";
+import fs18 from "fs";
+import os12 from "os";
+import path23 from "path";
 import { fileURLToPath } from "url";
 function vsCodeUserDirs() {
-  const home = os11.homedir();
+  const home = os12.homedir();
   const dirs = [
-    path21.join(home, "Library", "Application Support", "Code", "User"),
-    path21.join(home, ".config", "Code", "User")
+    path23.join(home, "Library", "Application Support", "Code", "User"),
+    path23.join(home, ".config", "Code", "User")
   ];
   if (process.env.APPDATA) {
-    dirs.push(path21.join(process.env.APPDATA, "Code", "User"));
+    dirs.push(path23.join(process.env.APPDATA, "Code", "User"));
   }
   return dirs;
 }
@@ -15818,7 +16331,7 @@ function uriToFsPath(uri) {
 async function readWorkspaceFolder(workspaceJsonPath) {
   let raw;
   try {
-    raw = await fs17.promises.readFile(workspaceJsonPath, "utf-8");
+    raw = await fs18.promises.readFile(workspaceJsonPath, "utf-8");
   } catch {
     return null;
   }
@@ -15840,10 +16353,10 @@ var CopilotChatSource = class {
   async scan() {
     const results = [];
     for (const userDir of vsCodeUserDirs()) {
-      const workspaceStorage = path21.join(userDir, "workspaceStorage");
+      const workspaceStorage = path23.join(userDir, "workspaceStorage");
       let hashDirs;
       try {
-        hashDirs = await fs17.promises.readdir(workspaceStorage, {
+        hashDirs = await fs18.promises.readdir(workspaceStorage, {
           withFileTypes: true
         });
       } catch {
@@ -15851,22 +16364,22 @@ var CopilotChatSource = class {
       }
       for (const hash of hashDirs) {
         if (!hash.isDirectory()) continue;
-        const wsRoot = path21.join(workspaceStorage, hash.name);
-        const transcriptsDir = path21.join(
+        const wsRoot = path23.join(workspaceStorage, hash.name);
+        const transcriptsDir = path23.join(
           wsRoot,
           "GitHub.copilot-chat",
           "transcripts"
         );
         let transcriptEntries;
         try {
-          transcriptEntries = await fs17.promises.readdir(transcriptsDir, {
+          transcriptEntries = await fs18.promises.readdir(transcriptsDir, {
             withFileTypes: true
           });
         } catch {
           continue;
         }
         const repoPath = await readWorkspaceFolder(
-          path21.join(wsRoot, "workspace.json")
+          path23.join(wsRoot, "workspace.json")
         );
         if (!repoPath) continue;
         for (const entry of transcriptEntries) {
@@ -15874,7 +16387,7 @@ var CopilotChatSource = class {
           const sessionId = entry.name.slice(0, -".jsonl".length);
           results.push({
             sourceName: this.name,
-            absolutePath: path21.join(transcriptsDir, entry.name),
+            absolutePath: path23.join(transcriptsDir, entry.name),
             repoPath,
             metadata: { sessionId }
           });
@@ -15914,7 +16427,7 @@ function reportRedactionStats(noun, stats) {
 async function filterByTimeRange(group, range) {
   const results = await Promise.all(
     group.files.map(
-      (f) => fs18.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
+      (f) => fs19.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
     )
   );
   const filtered = [];
@@ -15941,10 +16454,10 @@ async function runInteractive() {
   s.start(`Scanning ${source.name} logs...`);
   const allFiles = await source.scan();
   const allGroups = await mergeByRepo(allFiles);
-  const repoRoot = path22.resolve(repo.root);
+  const repoRoot = path24.resolve(repo.root);
   const matching = allGroups.filter((g) => {
-    const resolved = path22.resolve(g.repoPath);
-    return resolved === repoRoot || resolved.startsWith(repoRoot + path22.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}.`);
@@ -15975,7 +16488,7 @@ async function runInteractive() {
     }
   }
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path22.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path24.join(repoRoot, n));
   const additionalFiles = await promptSecretFiles(envFileNames);
   const secretResult = await collectSecrets(
     repoRoot,