hillclimb 0.2.0 → 0.4.0

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs17 from "fs";
-import path20 from "path";
+import fs18 from "fs";
+import path22 from "path";
 import * as p6 from "@clack/prompts";
 
 // src/commands/init.ts
@@ -28,8 +28,7 @@ var cyan = wrap(36, 39);
 import fs from "fs";
 import os from "os";
 import path from "path";
-var CONFIG_DIR = path.join(os.homedir(), ".hillclimb");
-var CONFIG_PATH = path.join(CONFIG_DIR, "projects.json");
+var DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".hillclimb");
 function normalizeProjectConfig(raw) {
   if (!raw || typeof raw !== "object") return null;
   const config = raw;
@@ -54,14 +53,14 @@ function normalizeProjectConfig(raw) {
   };
 }
 function configDir() {
-  return CONFIG_DIR;
+  return process.env.HILLCLIMB_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
 }
 function configPath() {
-  return CONFIG_PATH;
+  return path.join(configDir(), "projects.json");
 }
 async function loadProjects() {
   try {
-    const raw = await fs.promises.readFile(CONFIG_PATH, "utf-8");
+    const raw = await fs.promises.readFile(configPath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.projects || typeof parsed.projects !== "object") {
       return { projects: {} };
@@ -77,12 +76,12 @@ async function loadProjects() {
   }
 }
 async function saveProjects(file) {
-  await fs.promises.mkdir(CONFIG_DIR, { recursive: true, mode: 448 });
-  const tmp = `${CONFIG_PATH}.tmp`;
+  await fs.promises.mkdir(configDir(), { recursive: true, mode: 448 });
+  const tmp = `${configPath()}.tmp`;
   await fs.promises.writeFile(tmp, JSON.stringify(file, null, 2), {
     mode: 384
   });
-  await fs.promises.rename(tmp, CONFIG_PATH);
+  await fs.promises.rename(tmp, configPath());
 }
 async function upsertProject(repoRoot, config) {
   const file = await loadProjects();
@@ -177,13 +176,15 @@ async function ensureGitignored(repoRoot, files) {
 // src/identity.ts
 import fs3 from "fs";
 import path4 from "path";
-var IDENTITY_PATH = path4.join(configDir(), "identity.json");
+function identityPath() {
+  return path4.join(configDir(), "identity.json");
+}
 function normalizeUrl(apiBaseUrl) {
   return apiBaseUrl.replace(/\/$/, "");
 }
 async function loadAllIdentities() {
   try {
-    const raw = await fs3.promises.readFile(IDENTITY_PATH, "utf-8");
+    const raw = await fs3.promises.readFile(identityPath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.identities || typeof parsed.identities !== "object") {
       return { identities: {} };
@@ -199,11 +200,11 @@ async function loadIdentity(apiBaseUrl) {
 }
 async function writeIdentityFile(file) {
   await fs3.promises.mkdir(configDir(), { recursive: true, mode: 448 });
-  const tmp = `${IDENTITY_PATH}.tmp`;
+  const tmp = `${identityPath()}.tmp`;
   await fs3.promises.writeFile(tmp, JSON.stringify(file, null, 2), {
     mode: 384
   });
-  await fs3.promises.rename(tmp, IDENTITY_PATH);
+  await fs3.promises.rename(tmp, identityPath());
 }
 async function saveIdentity(identity) {
   const file = await loadAllIdentities();
@@ -602,6 +603,8 @@ import path6 from "path";
 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;
+var DEV_HOOK_ENV = "HILLCLIMB_DEV_HOOK=1";
+var SKIP_SELF_HEAL_ENV = "HILLCLIMB_SKIP_HOOK_SELF_HEAL=1";
 var TOOLS = [
   {
     tool: "claude",
@@ -764,17 +767,18 @@ function claudeCheck(settings, eventName, command, options = {}) {
   const matchers = settings.hooks?.[eventName] ?? [];
   return claudeHookPresent(matchers, command, options);
 }
-function claudeUninstall(settings, eventName, command) {
+function claudeUninstallMatching(settings, eventName, predicate) {
   const hooks = settings.hooks;
   const matchers = hooks?.[eventName];
   if (!hooks || !matchers || matchers.length === 0) return false;
   let removedAny = false;
   const next = [];
   for (const m of matchers) {
-    const remaining = (m.hooks ?? []).filter(
-      (h) => !(h.type === "command" && h.command === command)
-    );
-    if (remaining.length !== (m.hooks ?? []).length) removedAny = true;
+    const remaining = (m.hooks ?? []).filter((h) => {
+      const remove = h.type === "command" && typeof h.command === "string" && predicate(h.command);
+      if (remove) removedAny = true;
+      return !remove;
+    });
     if (remaining.length > 0) next.push({ ...m, hooks: remaining });
   }
   if (!removedAny) return false;
@@ -802,11 +806,11 @@ function cursorCheck(settings, eventName, command) {
   const entries = settings.hooks?.[eventName] ?? [];
   return cursorHookPresent(entries, command);
 }
-function cursorUninstall(settings, eventName, command) {
+function cursorUninstallMatching(settings, eventName, predicate) {
   const hooks = settings.hooks;
   const entries = hooks?.[eventName];
   if (!hooks || !entries || entries.length === 0) return false;
-  const next = entries.filter((e) => e.command !== command);
+  const next = entries.filter((e) => !predicate(e.command));
   if (next.length === entries.length) return false;
   if (next.length > 0) {
     hooks[eventName] = next;
@@ -834,12 +838,12 @@ function copilotCheck(settings, eventName, command) {
   const entries = settings.hooks?.[eventName] ?? [];
   return copilotHookPresent(entries, command);
 }
-function copilotUninstall(settings, eventName, command) {
+function copilotUninstallMatching(settings, eventName, predicate) {
   const hooks = settings.hooks;
   const entries = hooks?.[eventName];
   if (!hooks || !entries || entries.length === 0) return false;
   const next = entries.filter(
-    (e) => !(e.type === "command" && e.command === command)
+    (e) => !(e.type === "command" && predicate(e.command))
   );
   if (next.length === entries.length) return false;
   if (next.length > 0) {
@@ -850,7 +854,7 @@ function copilotUninstall(settings, eventName, command) {
   }
   return true;
 }
-var OPENCODE_PLUGIN_VERSION = 4;
+var OPENCODE_PLUGIN_VERSION = 6;
 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
@@ -952,7 +956,10 @@ export const HillclimbPlugin = async ({ directory }) => ({
     const type = event && event.type;
     const props = (event && event.properties) || {};
     const info = props.info || {};
-    const sessionID = props.sessionID || info.sessionID || info.id;
+    const sessionID =
+      props.sessionID ||
+      info.sessionID ||
+      (type === "message.updated" || type === "message.part.updated" ? undefined : info.id);
     const cwd = directory || props.directory || info.directory;
 
     if (type === "message.updated") {
@@ -990,11 +997,8 @@ export const HillclimbPlugin = async ({ directory }) => ({
 
     if (type === "session.deleted" && sessionID) {
       // User explicitly ended this session. Upload its transcript and drop
-      // the buffer. We do NOT clean up git-traces here: the user may still
-      // have other live sessions in this repo, and git-traces state is
-      // keyed per (repoRoot, tool) \u2014 clearing it here would wipe their
-      // concurrent session. Cleanup happens at server.instance.disposed
-      // (or on the next session.created via stale-state detection).
+      // the buffer. git-traces state is session-scoped, so this cleanup will
+      // not wipe another concurrent session in the same repo.
       const transcriptPath = writeTranscript(sessionID);
       if (transcriptPath) {
         spawnHillclimb("upload", {
@@ -1005,15 +1009,19 @@ export const HillclimbPlugin = async ({ directory }) => ({
           tool: TOOL,
         });
       }
+      spawnHillclimb("git-traces --tool=opencode", {
+        session_id: sessionID,
+        cwd,
+        hook_event_name: "session.deleted",
+        tool: TOOL,
+      });
       sessionMessages.delete(sessionID);
       return;
     }
 
     if (type === "server.instance.disposed") {
       // opencode is shutting down \u2014 flush every buffered session's transcript
-      // so nothing gets lost. Then clean up git-traces refs/state. No
-      // sessionID on this event, but git-traces state is keyed by
-      // (repoRoot, tool) so cwd alone is enough for handleSessionEnd.
+      // so nothing gets lost. Then clean up git-traces refs/state per session.
       for (const sid of sessionMessages.keys()) {
         const transcriptPath = writeTranscript(sid);
         if (transcriptPath) {
@@ -1025,8 +1033,15 @@ export const HillclimbPlugin = async ({ directory }) => ({
             tool: TOOL,
           });
         }
+        spawnHillclimb("git-traces --tool=opencode", {
+          session_id: sid,
+          cwd,
+          hook_event_name: "server.instance.disposed",
+          tool: TOOL,
+        });
       }
       sessionMessages.clear();
+      // Keep a no-session cleanup for pre-session-scoped legacy state.
       spawnHillclimb("git-traces --tool=opencode", {
         cwd,
         hook_event_name: "server.instance.disposed",
@@ -1039,16 +1054,16 @@ export const HillclimbPlugin = async ({ directory }) => ({
 
 export default HillclimbPlugin;
 `;
-async function opencodeInstall(file) {
+async function opencodeInstall(file, content = OPENCODE_PLUGIN_CONTENT) {
   try {
     const existing = await fs5.promises.readFile(file, "utf-8");
-    if (existing === OPENCODE_PLUGIN_CONTENT) {
+    if (existing === content) {
       return { installed: 0, alreadyPresent: 1 };
     }
   } catch {
   }
   await fs5.promises.mkdir(path6.dirname(file), { recursive: true });
-  await fs5.promises.writeFile(file, OPENCODE_PLUGIN_CONTENT);
+  await fs5.promises.writeFile(file, content);
   return { installed: 1, alreadyPresent: 0 };
 }
 async function opencodeCheck(file) {
@@ -1079,14 +1094,24 @@ function check(settings, format, eventName, command, options = {}) {
       return claudeCheck(settings, eventName, command, options);
   }
 }
-function uninstall(settings, format, eventName, command) {
+function commandsForEvent(settings, format, eventName) {
+  switch (format) {
+    case "cursor":
+      return (settings.hooks?.[eventName] ?? []).map((e) => e.command).filter((command) => typeof command === "string");
+    case "copilot":
+      return (settings.hooks?.[eventName] ?? []).filter((e) => e.type === "command").map((e) => e.command).filter((command) => typeof command === "string");
+    default:
+      return (settings.hooks?.[eventName] ?? []).flatMap((matcher) => matcher.hooks ?? []).filter((hook) => hook.type === "command").map((hook) => hook.command).filter((command) => typeof command === "string");
+  }
+}
+function uninstallMatching(settings, format, eventName, predicate) {
   switch (format) {
     case "cursor":
-      return cursorUninstall(settings, eventName, command);
+      return cursorUninstallMatching(settings, eventName, predicate);
     case "copilot":
-      return copilotUninstall(settings, eventName, command);
+      return copilotUninstallMatching(settings, eventName, predicate);
     default:
-      return claudeUninstall(settings, eventName, command);
+      return claudeUninstallMatching(settings, eventName, predicate);
   }
 }
 function legacyCommandsFor(command) {
@@ -1107,6 +1132,20 @@ function legacyCommandsFor(command) {
   }
   return legacy;
 }
+function legacyBareGitTracesCommandsFor(command) {
+  return legacyCommandsFor(command).filter(
+    (legacy) => legacy.endsWith(" git-traces")
+  );
+}
+function isHillclimbOwnedCommandFor(command, currentCommand) {
+  if (command === currentCommand || legacyCommandsFor(currentCommand).includes(command)) {
+    return true;
+  }
+  const prefix = "npx hillclimb@latest ";
+  if (!currentCommand.startsWith(prefix)) return false;
+  const subcommand = currentCommand.slice(prefix.length);
+  return command.endsWith(` ${subcommand}`) && (command.includes(DEV_HOOK_ENV) || command.includes(SKIP_SELF_HEAL_ENV) && command.includes("dist/cli.js"));
+}
 async function installHooksForTool(repoRoot, def) {
   const file = settingsPath(repoRoot, def);
   if (def.format === "opencode") {
@@ -1118,10 +1157,13 @@ async function installHooksForTool(repoRoot, def) {
   let alreadyPresent = 0;
   let mutated = false;
   for (const evt of def.events) {
-    for (const legacy of legacyCommandsFor(evt.command)) {
-      if (uninstall(settings, def.format, evt.eventName, legacy)) {
-        mutated = true;
-      }
+    if (uninstallMatching(
+      settings,
+      def.format,
+      evt.eventName,
+      (command) => command !== evt.command && isHillclimbOwnedCommandFor(command, evt.command)
+    )) {
+      mutated = true;
     }
     const added = install(settings, def.format, evt.eventName, evt.command, {
       timeout: evt.timeout
@@ -1157,6 +1199,27 @@ async function checkHooksForTool(repoRoot, def) {
   }
   return { allInstalled: missing.length === 0, settingsFile: file, missing };
 }
+async function findLegacyGitTracesHookOwners(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 git-traces --tool=")
+    );
+    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) => legacyBareGitTracesCommandsFor(evt.command).some(
+        (legacy) => commands.has(legacy)
+      )
+    )) {
+      owners.push(def.tool);
+    }
+  }
+  return owners;
+}
 function detectTools(repoRoot) {
   return TOOLS.filter((def) => def.detect(repoRoot));
 }
@@ -2086,9 +2149,14 @@ async function runStatus(args = []) {
 
 // src/commands/upload.ts
 import { spawn as spawn2 } from "child_process";
-import fs9 from "fs";
+import fs10 from "fs";
 import os5 from "os";
-import path12 from "path";
+import path13 from "path";
+
+// src/debug-logs.ts
+import crypto from "crypto";
+import fs9 from "fs";
+import path11 from "path";
 
 // src/middleware/pattern-redact.ts
 import os3 from "os";
@@ -10781,145 +10849,716 @@ async function collectSecrets(repoRoot, envFiles, additionalFiles) {
   return { values, sourceFiles, processEnvCount, skippedCount };
 }
 
-// src/normalizer/index.ts
-import path9 from "path";
+// src/outputs/platform.ts
+import { PassThrough } from "stream";
+import archiver from "archiver";
 
-// src/normalizer/claude.ts
-function stringify(value) {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
+// src/outputs/archive.ts
+import os4 from "os";
+import path9 from "path";
+function getSourceBaseDir(sourceName) {
+  const home = os4.homedir();
+  switch (sourceName) {
+    case "claude":
+      return path9.join(home, ".claude", "projects");
+    case "codex":
+      return path9.join(home, ".codex", "sessions");
+    case "debug-logs":
+      return path9.join(configDir(), "logs");
+    default:
+      return home;
   }
 }
-function extractTextReasoningToolUses(content) {
-  if (typeof content === "string") {
-    return [content.trim(), void 0, []];
-  }
-  const textParts = [];
-  const reasoningParts = [];
-  const toolBlocks = [];
-  if (Array.isArray(content)) {
-    for (const block of content) {
-      if (typeof block !== "object" || block === null) {
-        textParts.push(stringify(block));
-        continue;
-      }
-      const b = block;
-      const blockType = b.type;
-      if (blockType === "tool_use") {
-        toolBlocks.push(b);
-        continue;
-      }
-      if (blockType === "thinking" || blockType === "reasoning" || blockType === "analysis") {
-        const textValue2 = b.text !== void 0 && b.text !== null ? b.text : b.thinking;
-        if (typeof textValue2 === "string") {
-          reasoningParts.push(textValue2.trim());
-        } else {
-          reasoningParts.push(stringify(textValue2));
-        }
-        continue;
-      }
-      if (blockType === "code" && typeof b.code === "string") {
-        textParts.push(b.code);
-        continue;
-      }
-      const textValue = b.text;
-      if (typeof textValue === "string") {
-        textParts.push(textValue);
-      } else {
-        textParts.push(stringify(b));
-      }
+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);
+    if (file.content) {
+      archive.append(file.content, { name: archivePath });
+    } else {
+      archive.file(file.absolutePath, { name: archivePath });
     }
-  } else if (content !== void 0 && content !== null) {
-    textParts.push(stringify(content));
   }
-  const text3 = textParts.filter((p7) => p7 && p7.trim()).map((p7) => p7.trim()).join("\n\n");
-  const reasoning = reasoningParts.filter((p7) => p7 && p7.trim()).map((p7) => p7.trim()).join("\n\n");
-  return [text3, reasoning || void 0, toolBlocks];
 }
-function buildMetrics(usage) {
-  if (typeof usage !== "object" || usage === null) return void 0;
-  const u = usage;
-  const cachedTokens = u.cache_read_input_tokens || 0;
-  const creation = u.cache_creation_input_tokens || 0;
-  const inputTokens = u.input_tokens || 0;
-  const promptTokens = inputTokens + cachedTokens + creation;
-  const completionTokens = u.output_tokens || 0;
-  const extra = {};
-  for (const [key, value] of Object.entries(u)) {
-    if (key === "input_tokens" || key === "output_tokens") continue;
-    extra[key] = value;
-  }
-  return {
-    prompt_tokens: promptTokens,
-    completion_tokens: completionTokens,
-    cached_tokens: cachedTokens,
-    extra: Object.keys(extra).length > 0 ? extra : void 0
-  };
+
+// src/outputs/platform.ts
+async function buildZipBuffer(group, selectedSources) {
+  const archive = archiver("zip", { zlib: { level: 6 } });
+  const stream = new PassThrough();
+  archive.pipe(stream);
+  const chunks = [];
+  const done = new Promise((resolve, reject) => {
+    stream.on("data", (chunk) => chunks.push(chunk));
+    stream.on("end", resolve);
+    stream.on("error", reject);
+    archive.on("error", reject);
+  });
+  addGroupToArchive(archive, group, selectedSources);
+  await archive.finalize();
+  await done;
+  return Buffer.concat(chunks);
 }
-function formatToolResult(block, toolUseResult) {
-  const parts = [];
-  const content = block.content;
-  if (typeof content === "string") {
-    if (content.trim()) parts.push(content.trim());
-  } else if (Array.isArray(content)) {
-    for (const item of content) {
-      const text3 = stringify(item);
-      if (text3.trim()) parts.push(text3.trim());
-    }
-  } else if (content !== void 0 && content !== null && content !== "") {
-    parts.push(stringify(content));
+var PlatformUploadOutput = class {
+  constructor(opts) {
+    this.opts = opts;
   }
-  let metadata;
-  if (toolUseResult && typeof toolUseResult === "object") {
-    metadata = { tool_use_result: toolUseResult };
-    const stdout = toolUseResult.stdout;
-    const stderr = toolUseResult.stderr;
-    const exitCode = toolUseResult.exitCode ?? toolUseResult.exit_code;
-    const interrupted = toolUseResult.interrupted;
-    const isImage = toolUseResult.isImage;
-    const formatted = [];
-    if (stdout) formatted.push(`[stdout]
-${stdout}`.trimEnd());
-    if (stderr) formatted.push(`[stderr]
-${stderr}`.trimEnd());
-    if (exitCode !== void 0 && exitCode !== null && exitCode !== 0)
-      formatted.push(`[exit_code] ${exitCode}`);
-    if (interrupted) formatted.push(`[interrupted] ${interrupted}`);
-    if (isImage) formatted.push(`[is_image] ${isImage}`);
-    const skipKeys = /* @__PURE__ */ new Set([
-      "stdout",
-      "stderr",
-      "exitCode",
-      "exit_code",
-      "interrupted",
-      "isImage"
-    ]);
-    const remainingMeta = {};
-    for (const [k, v] of Object.entries(toolUseResult)) {
-      if (!skipKeys.has(k)) remainingMeta[k] = v;
-    }
-    if (Object.keys(remainingMeta).length > 0) {
-      formatted.push(`[metadata] ${JSON.stringify(remainingMeta)}`);
-    }
-    if (formatted.length > 0) {
-      parts.push(formatted.filter(Boolean).join("\n"));
+  name = "platform";
+  label = "Upload to hillclimb platform";
+  async emit(group, options) {
+    const selectedSources = new Set(options.selectedSources);
+    const buffer = await buildZipBuffer(group, selectedSources);
+    const {
+      client,
+      projectId,
+      contributionTypeSlug,
+      contributionTitle,
+      contributionBody,
+      zipFilename,
+      autoSubmit
+    } = this.opts;
+    const contribution = await client.createContribution(projectId, {
+      contributionTypeSlug,
+      title: contributionTitle,
+      body: contributionBody
+    });
+    const presigned = await client.createUpload(contribution.id, {
+      originalFilename: zipFilename,
+      mimeType: "application/zip",
+      sizeBytes: buffer.byteLength
+    });
+    appendLog(
+      "info",
+      `uploading ${zipFilename} (${buffer.byteLength} bytes) to presigned URL`
+    );
+    await client.uploadToPresignedUrl(
+      presigned.presignedUrl,
+      presigned.headers,
+      buffer
+    );
+    appendLog("info", `PUT to presigned URL succeeded for ${zipFilename}`);
+    if (autoSubmit) {
+      appendLog("info", `submitting contribution ${contribution.id}`);
+      await client.submitContribution(contribution.id);
+      appendLog("info", `contribution ${contribution.id} submitted`);
     }
+    return contribution.id;
   }
-  if (block.is_error === true) {
-    parts.push("[error] tool reported failure");
-    metadata = metadata || {};
-    metadata.is_error = true;
-  }
-  if (metadata !== void 0) {
-    if (!("raw_tool_result" in metadata)) {
-      metadata.raw_tool_result = block;
-    }
+};
+
+// src/pipeline.ts
+import fs8 from "fs";
+import path10 from "path";
+function canonicalizePath(p7) {
+  let resolved = path10.resolve(p7);
+  if (resolved.endsWith(path10.sep) && resolved !== path10.sep) {
+    resolved = resolved.slice(0, -1);
   }
-  const resultText = parts.filter(Boolean).join("\n\n").trim();
-  return [resultText || void 0, metadata];
+  return resolved;
+}
+function computeLabel(repoPath, allPaths) {
+  const segments = repoPath.split(path10.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);
+      return s.slice(-depth).join("/") === label;
+    });
+    if (matches.length === 1) return label;
+  }
+  return repoPath;
+}
+async function mergeByRepo(files) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const key = canonicalizePath(file.repoPath);
+    const existing = grouped.get(key);
+    if (existing) {
+      existing.push({ ...file, repoPath: key });
+    } else {
+      grouped.set(key, [{ ...file, repoPath: key }]);
+    }
+  }
+  const allPaths = [...grouped.keys()];
+  const groups = [];
+  for (const [repoPath, groupFiles] of grouped) {
+    const stats = await Promise.all(
+      groupFiles.map((f) => fs8.promises.stat(f.absolutePath).catch(() => null))
+    );
+    let lastModified = /* @__PURE__ */ new Date(0);
+    for (const stat of stats) {
+      if (stat && stat.mtime > lastModified) lastModified = stat.mtime;
+    }
+    const sourceNames = [...new Set(groupFiles.map((f) => f.sourceName))];
+    groups.push({
+      repoPath,
+      label: computeLabel(repoPath, allPaths),
+      files: groupFiles,
+      sourceNames,
+      lastModified
+    });
+  }
+  groups.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return groups.filter((g) => g.files.length > 0);
+}
+async function preloadFiles(group) {
+  const files = await Promise.all(
+    group.files.map(async (file) => {
+      if (file.content) return file;
+      try {
+        const buf = await fs8.promises.readFile(file.absolutePath);
+        const checkLen = Math.min(buf.length, 8192);
+        for (let i = 0; i < checkLen; i++) {
+          if (buf[i] === 0) {
+            return { ...file, content: buf, isBinary: true };
+          }
+        }
+        return { ...file, content: buf };
+      } catch {
+        return file;
+      }
+    })
+  );
+  return { ...group, files };
+}
+async function runPipeline(group, middleware2, output, options, onProgress) {
+  const preloaded = await preloadFiles(group);
+  let processed = preloaded;
+  for (const mw of middleware2) {
+    onProgress?.(`${mw.name} (${processed.files.length} files)`);
+    processed = await mw.process(processed);
+  }
+  onProgress?.(`Compressing ${processed.files.length} files`);
+  return output.emit(processed, options);
+}
+
+// src/debug-logs.ts
+var DEBUG_LOGS_SLUG = "debug-logs";
+var CURRENT_SCHEMA_VERSION = 1;
+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");
+}
+function waitMs() {
+  const raw = process.env.HILLCLIMB_DEBUG_LOG_WAIT_MS;
+  if (!raw) return DEFAULT_WAIT_MS;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_WAIT_MS;
+}
+function stateFile(eventId) {
+  return path11.join(stateDir(), `${eventId}.json`);
+}
+function lockFile(eventId) {
+  return `${stateFile(eventId)}.lock`;
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function sanitize(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function formatEpochSeconds(date) {
+  return String(Math.floor(date.getTime() / 1e3));
+}
+function toolLabel(tool) {
+  const labels = {
+    cursor: "Cursor",
+    codex: "Codex",
+    claude: "Claude",
+    "copilot-chat": "GitHub Copilot Chat",
+    opencode: "opencode"
+  };
+  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;
+}
+function resolveSessionId(payload) {
+  return payload.session_id ?? payload.conversation_id ?? null;
+}
+function stringOrNull(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function expectedKinds(tool, eventKind, payload) {
+  if (eventKind === "stop") {
+    return new Set(
+      tool === "codex" || tool === "copilot-chat" ? ["agent", "git"] : ["git"]
+    );
+  }
+  if (tool === "opencode" && !resolveSessionId(payload)) {
+    return /* @__PURE__ */ new Set(["git"]);
+  }
+  return /* @__PURE__ */ new Set(["agent", "git"]);
+}
+async function transcriptFingerprint(payload) {
+  const transcriptPath = stringOrNull(payload.transcript_path);
+  if (!transcriptPath) return {};
+  const resolved = path11.resolve(transcriptPath);
+  try {
+    const stat = await fs9.promises.stat(resolved);
+    return {
+      transcriptPath: resolved,
+      transcriptMtimeMs: stat.mtimeMs,
+      transcriptSizeBytes: stat.size
+    };
+  } catch {
+    return { transcriptPath: resolved };
+  }
+}
+async function eventContext(tool, payload) {
+  const eventKind = classifyHookEvent(payload.hook_event_name);
+  if (!eventKind) return null;
+  const cwd = resolveCwd(payload);
+  if (!cwd) return null;
+  const project = await findProjectForCwd(cwd);
+  if (!project) return null;
+  const sessionId = resolveSessionId(payload);
+  const turnId = stringOrNull(payload.turn_id);
+  const transcriptPath = stringOrNull(payload.transcript_path);
+  if (!sessionId && !turnId && !transcriptPath) {
+    return null;
+  }
+  const expected = expectedKinds(tool, eventKind, payload);
+  const eventNonce = eventKind === "stop" && expected.size === 1 && expected.has("git") && !turnId && !transcriptPath ? crypto.randomBytes(8).toString("hex") : null;
+  const fingerprint = {
+    schema: "debug-log-event-v1",
+    apiBaseUrl: project.config.apiBaseUrl,
+    projectId: project.config.projectId,
+    repoRoot: project.repoRoot,
+    tool,
+    eventKind,
+    hookEventName: payload.hook_event_name ?? null,
+    sessionId,
+    conversationId: stringOrNull(payload.conversation_id),
+    turnId,
+    eventNonce,
+    ...await transcriptFingerprint(payload)
+  };
+  const eventId = crypto.createHash("sha256").update(JSON.stringify(fingerprint)).digest("hex").slice(0, 32);
+  return {
+    eventId,
+    repoRoot: project.repoRoot,
+    config: project.config,
+    tool,
+    eventKind,
+    hookEventName: payload.hook_event_name ?? null,
+    sessionId,
+    expectedKinds: expected
+  };
+}
+async function readState(eventId) {
+  try {
+    const raw = await fs9.promises.readFile(stateFile(eventId), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeState(state) {
+  await fs9.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+  const file = stateFile(state.eventId);
+  const tmp = `${file}.tmp`;
+  await fs9.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+    mode: 384
+  });
+  await fs9.promises.rename(tmp, file);
+}
+async function acquireLock(eventId) {
+  await fs9.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+  for (let i = 0; i < LOCK_RETRIES; i++) {
+    try {
+      const fd = await fs9.promises.open(
+        lockFile(eventId),
+        fs9.constants.O_CREAT | fs9.constants.O_EXCL | fs9.constants.O_WRONLY
+      );
+      await fd.write(String(process.pid));
+      await fd.close();
+      return;
+    } catch (err) {
+      if (err.code === "EEXIST" && i < LOCK_RETRIES - 1) {
+        await sleep2(LOCK_RETRY_DELAY_MS);
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+async function releaseLock(eventId) {
+  try {
+    await fs9.promises.unlink(lockFile(eventId));
+  } catch {
+  }
+}
+function initialState(ctx, now) {
+  return {
+    schemaVersion: CURRENT_SCHEMA_VERSION,
+    eventId: ctx.eventId,
+    apiBaseUrl: ctx.config.apiBaseUrl,
+    projectId: ctx.config.projectId,
+    projectSlug: ctx.config.projectSlug,
+    repoRoot: ctx.repoRoot,
+    tool: ctx.tool,
+    eventKind: ctx.eventKind,
+    hookEventName: ctx.hookEventName,
+    sessionId: ctx.sessionId,
+    logDate: path11.basename(todayLogPath(), ".log"),
+    firstSeenAt: now.toISOString()
+  };
+}
+function markDone(state, kind, now) {
+  if (kind === "agent") {
+    return { ...state, agentDoneAt: state.agentDoneAt ?? now.toISOString() };
+  }
+  return { ...state, gitDoneAt: state.gitDoneAt ?? now.toISOString() };
+}
+function expectedComplete(state, expected) {
+  if (expected.has("agent") && !state.agentDoneAt) return false;
+  if (expected.has("git") && !state.gitDoneAt) return false;
+  return true;
+}
+function formatKinds(kinds) {
+  return [...kinds].sort().join("+") || "<none>";
+}
+function observedKinds(state) {
+  const observed = [];
+  if (state.agentDoneAt) observed.push("agent");
+  if (state.gitDoneAt) observed.push("git");
+  return observed;
+}
+function elapsedSince(iso, now) {
+  const started = Date.parse(iso);
+  return Number.isNaN(started) ? 0 : Math.max(0, now.getTime() - started);
+}
+async function recordMarker(ctx, kind) {
+  await acquireLock(ctx.eventId);
+  try {
+    const now = /* @__PURE__ */ new Date();
+    const state = await readState(ctx.eventId) ?? initialState(ctx, now);
+    const next = markDone(state, kind, now);
+    await writeState(next);
+    return next;
+  } finally {
+    await releaseLock(ctx.eventId);
+  }
+}
+async function waitForExpectedKinds(ctx, state) {
+  if (expectedComplete(state, ctx.expectedKinds) || state.uploadedAt) {
+    return state;
+  }
+  const started = Date.now();
+  const maxWaitMs = waitMs();
+  while (Date.now() - started < maxWaitMs) {
+    await sleep2(Math.min(250, Math.max(25, maxWaitMs)));
+    const latest = await readState(ctx.eventId);
+    if (!latest) continue;
+    if (expectedComplete(latest, ctx.expectedKinds) || latest.uploadedAt) {
+      return latest;
+    }
+  }
+  appendLog(
+    "warn",
+    `debug-logs: timed out waiting for ${[...ctx.expectedKinds].join("+")} completion (event=${ctx.eventId}, tool=${ctx.tool})`
+  );
+  return await readState(ctx.eventId) ?? state;
+}
+async function buildMiddleware(repoRoot) {
+  const envFileNames = await discoverEnvFiles(repoRoot);
+  const envFilePaths = envFileNames.map((n) => path11.join(repoRoot, n));
+  const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
+  const middleware2 = [];
+  if (secretResult.values.size > 0) {
+    middleware2.push(new RedactMiddleware(secretResult.values));
+  }
+  middleware2.push(new PatternRedactMiddleware());
+  return middleware2;
+}
+async function uploadDebugLog(ctx, state) {
+  const logPath = todayLogPath();
+  let content;
+  try {
+    content = await fs9.promises.readFile(logPath);
+  } catch (err) {
+    appendLog(
+      "warn",
+      `debug-logs: skipped upload; log file not readable (${logPath}): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+  if (content.byteLength === 0) {
+    appendLog("info", "debug-logs: skipped upload; log file is empty");
+    return null;
+  }
+  const identity = await loadIdentity(ctx.config.apiBaseUrl);
+  if (!identity) {
+    appendLog(
+      "warn",
+      `debug-logs: skipped upload; no saved login for ${ctx.config.apiBaseUrl}`
+    );
+    return null;
+  }
+  const now = /* @__PURE__ */ new Date();
+  appendLog(
+    "info",
+    `debug-logs: uploading event=${ctx.eventId} session=${ctx.sessionId ?? "<none>"} tool=${ctx.tool} expected=${formatKinds(ctx.expectedKinds)} observed=${formatKinds(observedKinds(state))} waitedMs=${elapsedSince(state.firstSeenAt, now)} project=${ctx.config.projectSlug} (${ctx.config.projectId}) apiBaseUrl=${ctx.config.apiBaseUrl}`
+  );
+  const sourceFile = {
+    sourceName: DEBUG_LOGS_SLUG,
+    absolutePath: logPath,
+    repoPath: ctx.repoRoot,
+    content
+  };
+  const group = {
+    repoPath: ctx.repoRoot,
+    label: path11.basename(ctx.repoRoot),
+    files: [sourceFile],
+    sourceNames: [DEBUG_LOGS_SLUG],
+    lastModified: now
+  };
+  const shortSession = (ctx.sessionId ?? ctx.eventId).slice(0, 12);
+  const epochSeconds = formatEpochSeconds(now);
+  const label = toolLabel(ctx.tool);
+  const client = new PlatformClient(
+    ctx.config.apiBaseUrl,
+    identity.sessionCookie
+  );
+  const output = new PlatformUploadOutput({
+    client,
+    projectId: ctx.config.projectId,
+    contributionTypeSlug: DEBUG_LOGS_SLUG,
+    contributionTitle: `${label} debug log ${shortSession} - ${epochSeconds}`,
+    contributionBody: [
+      `Session ID: ${ctx.sessionId ?? "<none>"}`,
+      `Tool: ${label}`,
+      `Event: ${ctx.hookEventName ?? ctx.eventKind}`,
+      `Repo: ${ctx.repoRoot}`,
+      `Log: ${path11.basename(logPath)}`,
+      `Agent done: ${state.agentDoneAt ?? "<not observed>"}`,
+      `Git done: ${state.gitDoneAt ?? "<not observed>"}`,
+      `Uploaded: ${now.toISOString()}`
+    ].join("\n"),
+    zipFilename: `hillclimb-debug-log-${sanitize(ctx.tool)}-${sanitize(shortSession)}-${epochSeconds}.zip`,
+    autoSubmit: true
+  });
+  try {
+    const contributionId = await runPipeline(
+      group,
+      await buildMiddleware(ctx.repoRoot),
+      output,
+      { selectedSources: [DEBUG_LOGS_SLUG] }
+    );
+    appendLog(
+      "info",
+      `debug-logs: uploaded ${path11.basename(logPath)} to project ${ctx.config.projectSlug} (${ctx.config.projectId}) as contribution ${contributionId}`
+    );
+    return contributionId;
+  } catch (err) {
+    if (err instanceof PlatformError && err.status === 404) {
+      appendLog(
+        "warn",
+        "debug-logs: upload skipped; platform does not have the debug-logs contribution type yet"
+      );
+      return null;
+    }
+    appendLog(
+      "error",
+      `debug-logs: upload failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
+async function uploadOnce(ctx, state) {
+  await acquireLock(ctx.eventId);
+  try {
+    const latest = await readState(ctx.eventId) ?? state;
+    if (latest.uploadedAt) return;
+    const contributionId = await uploadDebugLog(ctx, latest);
+    if (!contributionId) return;
+    const uploadedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeState({
+      ...latest,
+      uploadedAt,
+      uploadContributionId: contributionId ?? void 0
+    });
+  } finally {
+    await releaseLock(ctx.eventId);
+  }
+}
+async function recordDebugLogCompletion(args) {
+  if (process.env.HILLCLIMB_DEBUG_LOG_UPLOAD === "0") return;
+  try {
+    const ctx = await eventContext(args.tool, args.payload);
+    if (!ctx) return;
+    const marked = await recordMarker(ctx, args.kind);
+    const ready = await waitForExpectedKinds(ctx, marked);
+    if (ready.uploadedAt) return;
+    await uploadOnce(ctx, ready);
+  } catch (err) {
+    appendLog(
+      "warn",
+      `debug-logs: failed to record completion: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
+// src/normalizer/index.ts
+import path12 from "path";
+
+// src/normalizer/claude.ts
+function stringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractTextReasoningToolUses(content) {
+  if (typeof content === "string") {
+    return [content.trim(), void 0, []];
+  }
+  const textParts = [];
+  const reasoningParts = [];
+  const toolBlocks = [];
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (typeof block !== "object" || block === null) {
+        textParts.push(stringify(block));
+        continue;
+      }
+      const b = block;
+      const blockType = b.type;
+      if (blockType === "tool_use") {
+        toolBlocks.push(b);
+        continue;
+      }
+      if (blockType === "thinking" || blockType === "reasoning" || blockType === "analysis") {
+        const textValue2 = b.text !== void 0 && b.text !== null ? b.text : b.thinking;
+        if (typeof textValue2 === "string") {
+          reasoningParts.push(textValue2.trim());
+        } else {
+          reasoningParts.push(stringify(textValue2));
+        }
+        continue;
+      }
+      if (blockType === "code" && typeof b.code === "string") {
+        textParts.push(b.code);
+        continue;
+      }
+      const textValue = b.text;
+      if (typeof textValue === "string") {
+        textParts.push(textValue);
+      } else {
+        textParts.push(stringify(b));
+      }
+    }
+  } else if (content !== void 0 && content !== null) {
+    textParts.push(stringify(content));
+  }
+  const text3 = textParts.filter((p7) => p7 && p7.trim()).map((p7) => p7.trim()).join("\n\n");
+  const reasoning = reasoningParts.filter((p7) => p7 && p7.trim()).map((p7) => p7.trim()).join("\n\n");
+  return [text3, reasoning || void 0, toolBlocks];
+}
+function buildMetrics(usage) {
+  if (typeof usage !== "object" || usage === null) return void 0;
+  const u = usage;
+  const cachedTokens = u.cache_read_input_tokens || 0;
+  const creation = u.cache_creation_input_tokens || 0;
+  const inputTokens = u.input_tokens || 0;
+  const promptTokens = inputTokens + cachedTokens + creation;
+  const completionTokens = u.output_tokens || 0;
+  const extra = {};
+  for (const [key, value] of Object.entries(u)) {
+    if (key === "input_tokens" || key === "output_tokens") continue;
+    extra[key] = value;
+  }
+  return {
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    cached_tokens: cachedTokens,
+    extra: Object.keys(extra).length > 0 ? extra : void 0
+  };
+}
+function formatToolResult(block, toolUseResult) {
+  const parts = [];
+  const content = block.content;
+  if (typeof content === "string") {
+    if (content.trim()) parts.push(content.trim());
+  } else if (Array.isArray(content)) {
+    for (const item of content) {
+      const text3 = stringify(item);
+      if (text3.trim()) parts.push(text3.trim());
+    }
+  } else if (content !== void 0 && content !== null && content !== "") {
+    parts.push(stringify(content));
+  }
+  let metadata;
+  if (toolUseResult && typeof toolUseResult === "object") {
+    metadata = { tool_use_result: toolUseResult };
+    const stdout = toolUseResult.stdout;
+    const stderr = toolUseResult.stderr;
+    const exitCode = toolUseResult.exitCode ?? toolUseResult.exit_code;
+    const interrupted = toolUseResult.interrupted;
+    const isImage = toolUseResult.isImage;
+    const formatted = [];
+    if (stdout) formatted.push(`[stdout]
+${stdout}`.trimEnd());
+    if (stderr) formatted.push(`[stderr]
+${stderr}`.trimEnd());
+    if (exitCode !== void 0 && exitCode !== null && exitCode !== 0)
+      formatted.push(`[exit_code] ${exitCode}`);
+    if (interrupted) formatted.push(`[interrupted] ${interrupted}`);
+    if (isImage) formatted.push(`[is_image] ${isImage}`);
+    const skipKeys = /* @__PURE__ */ new Set([
+      "stdout",
+      "stderr",
+      "exitCode",
+      "exit_code",
+      "interrupted",
+      "isImage"
+    ]);
+    const remainingMeta = {};
+    for (const [k, v] of Object.entries(toolUseResult)) {
+      if (!skipKeys.has(k)) remainingMeta[k] = v;
+    }
+    if (Object.keys(remainingMeta).length > 0) {
+      formatted.push(`[metadata] ${JSON.stringify(remainingMeta)}`);
+    }
+    if (formatted.length > 0) {
+      parts.push(formatted.filter(Boolean).join("\n"));
+    }
+  }
+  if (block.is_error === true) {
+    parts.push("[error] tool reported failure");
+    metadata = metadata || {};
+    metadata.is_error = true;
+  }
+  if (metadata !== void 0) {
+    if (!("raw_tool_result" in metadata)) {
+      metadata.raw_tool_result = block;
+    }
+  }
+  const resultText = parts.filter(Boolean).join("\n\n").trim();
+  return [resultText || void 0, metadata];
 }
 function convertClaudeToTrajectory(jsonlContent, sessionId) {
   const rawEvents = [];
@@ -11304,6 +11943,59 @@ function parseOutputBlob(raw) {
   }
   return [String(parsed), void 0];
 }
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function compactExtra(extra) {
+  const compacted = {};
+  for (const [key, value] of Object.entries(extra)) {
+    if (value !== void 0 && value !== null) compacted[key] = value;
+  }
+  return Object.keys(compacted).length > 0 ? compacted : void 0;
+}
+function parseJsonObject(raw) {
+  const obj = asObject(raw);
+  if (obj) return obj;
+  if (typeof raw !== "string") return void 0;
+  try {
+    return asObject(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+}
+function subagentRefFromSpawnOutput(args, rawOutput) {
+  const output = parseJsonObject(rawOutput);
+  const sessionId = typeof output?.agent_id === "string" && output.agent_id || typeof output?.agent_path === "string" && output.agent_path || void 0;
+  if (!sessionId) return void 0;
+  const extra = compactExtra({
+    agent_role: typeof args?.agent_type === "string" && args.agent_type || typeof output?.agent_role === "string" && output.agent_role || void 0,
+    nickname: typeof output?.nickname === "string" && output.nickname || typeof output?.agent_nickname === "string" && output.agent_nickname || void 0
+  });
+  return {
+    session_id: sessionId,
+    extra
+  };
+}
+function codexTrajectoryExtra(metaPayload) {
+  const source = asObject(metaPayload.source);
+  const subagent = asObject(source?.subagent);
+  const threadSpawn = asObject(subagent?.thread_spawn);
+  const parentThreadId = typeof threadSpawn?.parent_thread_id === "string" ? threadSpawn.parent_thread_id : void 0;
+  const subagentExtra = threadSpawn ? compactExtra({
+    depth: threadSpawn.depth,
+    agent_path: threadSpawn.agent_path,
+    agent_nickname: threadSpawn.agent_nickname,
+    agent_role: threadSpawn.agent_role
+  }) : void 0;
+  return compactExtra({
+    thread_source: metaPayload.thread_source,
+    agent_nickname: metaPayload.agent_nickname,
+    agent_role: metaPayload.agent_role,
+    parent_session_id: parentThreadId,
+    parent_thread_id: parentThreadId,
+    subagent: subagentExtra
+  });
+}
 function convertCodexToTrajectory(jsonlContent, sessionId) {
   const rawEvents = [];
   for (const line of jsonlContent.split("\n")) {
@@ -11317,7 +12009,7 @@ function convertCodexToTrajectory(jsonlContent, sessionId) {
   if (rawEvents.length === 0) return null;
   const sessionMeta = rawEvents.find((e) => e.type === "session_meta");
   const metaPayload = sessionMeta?.payload ?? {};
-  const sid = sessionId ?? metaPayload.id ?? "";
+  const sid = sessionId ?? (typeof metaPayload.id === "string" ? metaPayload.id : "");
   const agentVersion = metaPayload.cli_version ?? "unknown";
   const agentExtra = {};
   for (const key of ["originator", "cwd", "git", "instructions"]) {
@@ -11434,6 +12126,13 @@ function convertCodexToTrajectory(jsonlContent, sessionId) {
       callInfo.output = outputText;
       callInfo.metadata = metadata;
       callInfo.timestamp = callInfo.timestamp ?? timestamp;
+      if (callInfo.tool_name === "spawn_agent") {
+        const subagentRef = subagentRefFromSpawnOutput(
+          callInfo.arguments,
+          payload.output
+        );
+        if (subagentRef) callInfo.subagentRefs = [subagentRef];
+      }
       normalizedEvents.push(callInfo);
       pendingReasoning = void 0;
     }
@@ -11489,7 +12188,8 @@ function convertCodexToTrajectory(jsonlContent, sessionId) {
       extra: Object.keys(agentExtra).length > 0 ? agentExtra : void 0
     },
     steps,
-    final_metrics: finalMetrics
+    final_metrics: finalMetrics,
+    extra: codexTrajectoryExtra(metaPayload)
   };
 }
 function convertEventToStep2(event, stepId, defaultModelName) {
@@ -11524,7 +12224,8 @@ function convertEventToStep2(event, stepId, defaultModelName) {
     if (event.output !== void 0) {
       const result = {
         source_call_id: callId || void 0,
-        content: event.output
+        content: event.output,
+        subagent_trajectory_ref: event.subagentRefs
       };
       observation = { results: [result] };
     }
@@ -11572,13 +12273,13 @@ function excludeNone(obj) {
 }
 
 // src/normalizer/copilotChat.ts
-function asObject(value) {
+function asObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function asNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function compactExtra(extra) {
+function compactExtra2(extra) {
   const result = {};
   for (const [key, value] of Object.entries(extra)) {
     if (value !== void 0 && value !== null) result[key] = value;
@@ -11591,11 +12292,11 @@ function parseJsonLines(content) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
-      const parsed = asObject(JSON.parse(trimmed));
+      const parsed = asObject2(JSON.parse(trimmed));
       if (!parsed) continue;
       entries.push({
         type: typeof parsed.type === "string" ? parsed.type : void 0,
-        data: asObject(parsed.data),
+        data: asObject2(parsed.data),
         id: typeof parsed.id === "string" ? parsed.id : void 0,
         timestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : void 0
       });
@@ -11605,11 +12306,11 @@ function parseJsonLines(content) {
   return entries;
 }
 function parseArguments(value) {
-  const obj = asObject(value);
+  const obj = asObject2(value);
   if (obj) return obj;
   if (typeof value === "string") {
     try {
-      const parsed = asObject(JSON.parse(value));
+      const parsed = asObject2(JSON.parse(value));
       if (parsed) return parsed;
     } catch {
       return value ? { input: value } : {};
@@ -11631,7 +12332,7 @@ function buildMetrics2(data) {
     completion_tokens: outputTokens || void 0,
     cached_tokens: cacheReadTokens || void 0,
     cost_usd: cost || void 0,
-    extra: compactExtra({
+    extra: compactExtra2({
       cache_write_tokens: cacheWriteTokens || void 0,
       duration_ms: data.duration,
       initiator: data.initiator,
@@ -11663,7 +12364,7 @@ function finalMetricsFromSteps(steps) {
   };
 }
 function makeToolCall(request) {
-  const req = asObject(request);
+  const req = asObject2(request);
   if (!req) return null;
   const callId = typeof req.toolCallId === "string" && req.toolCallId || typeof req.id === "string" && req.id || "";
   const name = typeof req.name === "string" && req.name || typeof req.toolName === "string" && req.toolName || "tool";
@@ -11683,7 +12384,7 @@ function toolCallFromExecutionStart(data) {
   };
 }
 function contentFromToolResult(data) {
-  const result = asObject(data.result);
+  const result = asObject2(data.result);
   if (typeof result?.content === "string") return result.content;
   if (typeof data.content === "string") return data.content;
   return void 0;
@@ -11709,7 +12410,7 @@ function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
         copilotVersion = data.copilotVersion;
       if (typeof data.vscodeVersion === "string")
         vscodeVersion = data.vscodeVersion;
-      const context = asObject(data.context);
+      const context = asObject2(data.context);
       if (typeof context?.cwd === "string") cwd = context.cwd;
       continue;
     }
@@ -11722,7 +12423,7 @@ function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
         timestamp: entry.timestamp,
         source,
         message: content,
-        extra: compactExtra({
+        extra: compactExtra2({
           attachments: data.attachments,
           source: data.source,
           agent_mode: data.agentMode,
@@ -11752,7 +12453,7 @@ function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
         source: "agent",
         message: content || (toolCalls.length > 0 ? "(tool use)" : ""),
         model_name: defaultModelName,
-        extra: compactExtra({
+        extra: compactExtra2({
           message_id: data.messageId,
           phase: data.phase,
           output_tokens: data.outputTokens
@@ -11798,7 +12499,7 @@ function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
         target.observation = observation;
         const extra = { ...target.extra ?? {} };
         extra.tool_success = data.success;
-        target.extra = compactExtra(extra);
+        target.extra = compactExtra2(extra);
       }
       if (callId) pendingToolSteps.delete(callId);
       continue;
@@ -11824,7 +12525,7 @@ function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
       name: "github-copilot-chat",
       version: copilotVersion,
       model_name: defaultModelName,
-      extra: compactExtra({
+      extra: compactExtra2({
         vscode_version: vscodeVersion,
         cwd
       })
@@ -11892,7 +12593,7 @@ function convertCursorToTrajectory(jsonlContent, sessionId) {
 }
 
 // src/normalizer/opencode.ts
-function asObject2(value) {
+function asObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function asArray(value) {
@@ -11901,7 +12602,7 @@ function asArray(value) {
 function asNumber2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function compactExtra2(extra) {
+function compactExtra3(extra) {
   const result = {};
   for (const [key, value] of Object.entries(extra)) {
     if (value !== void 0 && value !== null) result[key] = value;
@@ -11915,7 +12616,7 @@ function parseJsonLines2(content) {
     if (!trimmed) continue;
     try {
       const parsed = JSON.parse(trimmed);
-      const obj = asObject2(parsed);
+      const obj = asObject3(parsed);
       if (obj) events.push(obj);
     } catch {
     }
@@ -11930,7 +12631,7 @@ function timestampToIso(value) {
   return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
 }
 function timeFromObject(value) {
-  const obj = asObject2(value);
+  const obj = asObject3(value);
   if (!obj) return void 0;
   return timestampToIso(obj.start ?? obj.created ?? obj.completed ?? obj.end);
 }
@@ -11943,12 +12644,12 @@ function stringify2(value) {
   }
 }
 function argsFromUnknown(value) {
-  const obj = asObject2(value);
+  const obj = asObject3(value);
   if (obj) return obj;
   if (typeof value === "string") {
     try {
       const parsed = JSON.parse(value);
-      const parsedObj = asObject2(parsed);
+      const parsedObj = asObject3(parsed);
       if (parsedObj) return parsedObj;
     } catch {
       return value ? { input: value } : {};
@@ -11957,16 +12658,16 @@ function argsFromUnknown(value) {
   return value === void 0 || value === null ? {} : { value };
 }
 function modelNameFromInfo(info) {
-  const model = asObject2(info.model);
+  const model = asObject3(info.model);
   const modelID = typeof info.modelID === "string" && info.modelID || typeof model?.modelID === "string" && model.modelID || void 0;
   const providerID = typeof info.providerID === "string" && info.providerID || typeof model?.providerID === "string" && model.providerID || void 0;
   if (providerID && modelID) return `${providerID}/${modelID}`;
   return modelID;
 }
 function metricsFromTokens(tokens, cost) {
-  const t = asObject2(tokens);
+  const t = asObject3(tokens);
   if (!t) return void 0;
-  const cache = asObject2(t.cache);
+  const cache = asObject3(t.cache);
   const input = asNumber2(t.input) ?? 0;
   const output = asNumber2(t.output) ?? 0;
   const reasoning = asNumber2(t.reasoning) ?? 0;
@@ -11976,7 +12677,7 @@ function metricsFromTokens(tokens, cost) {
   if (!input && !output && !cacheRead && !cacheWrite && !costUsd) {
     return void 0;
   }
-  const extra = compactExtra2({
+  const extra = compactExtra3({
     reasoning_tokens: reasoning || void 0,
     cache_write_tokens: cacheWrite || void 0
   });
@@ -12017,12 +12718,12 @@ function finalMetricsFromSteps2(steps) {
   };
 }
 function entryFromLine(line) {
-  const info = asObject2(line.info);
+  const info = asObject3(line.info);
   if (info) {
     return {
       info,
       parts: asArray(line.parts).flatMap((part) => {
-        const obj = asObject2(part);
+        const obj = asObject3(part);
         return obj ? [obj] : [];
       })
     };
@@ -12031,7 +12732,7 @@ function entryFromLine(line) {
     return {
       info: line,
       parts: asArray(line.parts).flatMap((part) => {
-        const obj = asObject2(part);
+        const obj = asObject3(part);
         return obj ? [obj] : [];
       })
     };
@@ -12050,9 +12751,9 @@ function entriesFromEventWrappers(lines) {
   }
   for (const line of lines) {
     const type = line.type;
-    const props = asObject2(line.properties) ?? line;
+    const props = asObject3(line.properties) ?? line;
     if (type === "message.updated") {
-      const info = asObject2(props.info);
+      const info = asObject3(props.info);
       const id = typeof info?.id === "string" ? info.id : void 0;
       if (!info || !id) continue;
       const entry = getEntry(id, info.sessionID);
@@ -12060,7 +12761,7 @@ function entriesFromEventWrappers(lines) {
       continue;
     }
     if (type === "message.part.updated") {
-      const part = asObject2(props.part);
+      const part = asObject3(props.part);
       const messageID = typeof part?.messageID === "string" && part.messageID || void 0;
       if (!part || !messageID) continue;
       const entry = getEntry(messageID, part.sessionID);
@@ -12085,8 +12786,8 @@ function getAgentVersion(exportInfo) {
 }
 function sortEntries(entries) {
   return [...entries].sort((a, b) => {
-    const at = asNumber2(asObject2(a.info.time)?.created) ?? 0;
-    const bt = asNumber2(asObject2(b.info.time)?.created) ?? 0;
+    const at = asNumber2(asObject3(a.info.time)?.created) ?? 0;
+    const bt = asNumber2(asObject3(b.info.time)?.created) ?? 0;
     return at - bt;
   });
 }
@@ -12143,7 +12844,7 @@ function buildUserStep(entry, stepId, defaultModelName) {
     source: "user",
     message,
     model_name: defaultModelName,
-    extra: compactExtra2(extra)
+    extra: compactExtra3(extra)
   };
 }
 function buildAgentStep(parts, info, stepId, defaultModelName, fallbackMetrics) {
@@ -12173,7 +12874,7 @@ function buildAgentStep(parts, info, stepId, defaultModelName, fallbackMetrics)
         break;
       }
       case "tool": {
-        const state = asObject2(part.state) ?? {};
+        const state = asObject3(part.state) ?? {};
         const callID = typeof part.callID === "string" && part.callID || typeof part.id === "string" && part.id || "";
         const toolName = typeof part.tool === "string" && part.tool || "tool";
         const input = argsFromUnknown(state.input);
@@ -12227,7 +12928,7 @@ function buildAgentStep(parts, info, stepId, defaultModelName, fallbackMetrics)
   if (toolCalls.length > 0) step.tool_calls = toolCalls;
   if (observation) step.observation = observation;
   if (metrics) step.metrics = metrics;
-  const compactedExtra = compactExtra2(extra);
+  const compactedExtra = compactExtra3(extra);
   if (compactedExtra) step.extra = compactedExtra;
   return step;
 }
@@ -12243,7 +12944,7 @@ function buildUnavailableAgentStep(info, stepId, defaultModelName) {
     message: "(message unavailable)",
     model_name: modelNameFromInfo(info) ?? defaultModelName,
     metrics,
-    extra: compactExtra2({
+    extra: compactExtra3({
       content_unavailable: true,
       finish_reason: info.finish,
       error: info.error
@@ -12313,14 +13014,14 @@ function convertRunEventsToTrajectory(events, sessionId) {
     }
     if (type === "step_finish") {
       if (current) {
-        current.finish = asObject2(event.part) ?? {};
+        current.finish = asObject3(event.part) ?? {};
         turns.push(current);
         current = null;
       }
       continue;
     }
     if (current && (type === "text" || type === "reasoning" || type === "tool_use")) {
-      const part = asObject2(event.part);
+      const part = asObject3(event.part);
       if (part) current.parts.push(part);
     }
   }
@@ -12362,17 +13063,17 @@ function convertOpenCodeToTrajectory(content, sessionId) {
   if (!trimmed) return null;
   try {
     const parsed = JSON.parse(trimmed);
-    const parsedObj = asObject2(parsed);
+    const parsedObj = asObject3(parsed);
     const messages = asArray(parsedObj?.messages);
     if (parsedObj && messages.length > 0) {
       const entries2 = messages.flatMap((message) => {
-        const entry = entryFromLine(asObject2(message) ?? {});
+        const entry = entryFromLine(asObject3(message) ?? {});
         return entry ? [entry] : [];
       });
       return convertMessageEntriesToTrajectory(
         entries2,
         sessionId,
-        asObject2(parsedObj.info)
+        asObject3(parsedObj.info)
       );
     }
   } catch {
@@ -12405,228 +13106,46 @@ function normalizeContent(sourceName, content, sessionId) {
       return null;
   }
 }
-var NormalizeMiddleware = class {
-  name = "normalize";
-  async process(group) {
-    const newFiles = [];
-    for (const file of group.files) {
-      newFiles.push(file);
-      if (!file.absolutePath.endsWith(".jsonl")) continue;
-      if (!["claude", "codex", "cursor", "opencode", "copilot-chat"].includes(
-        file.sourceName
-      ))
-        continue;
-      const content = file.content ? file.content.toString("utf-8") : null;
-      if (!content) continue;
-      const sessionId = file.metadata?.sessionId ?? path9.basename(file.absolutePath, ".jsonl");
-      try {
-        const trajectory = normalizeContent(
-          file.sourceName,
-          content,
-          sessionId
-        );
-        if (!trajectory) continue;
-        const json = JSON.stringify(
-          excludeNone(trajectory),
-          null,
-          2
-        );
-        const atifPath = file.absolutePath.replace(/\.jsonl$/, ".atif.json");
-        newFiles.push({
-          sourceName: file.sourceName,
-          absolutePath: atifPath,
-          repoPath: file.repoPath,
-          metadata: { ...file.metadata, isAtif: true },
-          content: Buffer.from(json, "utf-8")
-        });
-      } catch {
-      }
-    }
-    return { ...group, files: newFiles };
-  }
-};
-
-// src/outputs/platform.ts
-import { PassThrough } from "stream";
-import archiver from "archiver";
-
-// src/outputs/archive.ts
-import os4 from "os";
-import path10 from "path";
-function getSourceBaseDir(sourceName) {
-  const home = os4.homedir();
-  switch (sourceName) {
-    case "claude":
-      return path10.join(home, ".claude", "projects");
-    case "codex":
-      return path10.join(home, ".codex", "sessions");
-    default:
-      return home;
-  }
-}
-function addGroupToArchive(archive, group, selectedSources) {
-  for (const file of group.files) {
-    if (!selectedSources.has(file.sourceName)) continue;
-    const baseDir = getSourceBaseDir(file.sourceName);
-    const relativePath = file.absolutePath.startsWith(baseDir) ? path10.relative(baseDir, file.absolutePath) : path10.basename(file.absolutePath);
-    const archivePath = path10.join(file.sourceName, relativePath);
-    if (file.content) {
-      archive.append(file.content, { name: archivePath });
-    } else {
-      archive.file(file.absolutePath, { name: archivePath });
-    }
-  }
-}
-
-// src/outputs/platform.ts
-async function buildZipBuffer(group, selectedSources) {
-  const archive = archiver("zip", { zlib: { level: 6 } });
-  const stream = new PassThrough();
-  archive.pipe(stream);
-  const chunks = [];
-  const done = new Promise((resolve, reject) => {
-    stream.on("data", (chunk) => chunks.push(chunk));
-    stream.on("end", resolve);
-    stream.on("error", reject);
-    archive.on("error", reject);
-  });
-  addGroupToArchive(archive, group, selectedSources);
-  await archive.finalize();
-  await done;
-  return Buffer.concat(chunks);
-}
-var PlatformUploadOutput = class {
-  constructor(opts) {
-    this.opts = opts;
-  }
-  name = "platform";
-  label = "Upload to hillclimb platform";
-  async emit(group, options) {
-    const selectedSources = new Set(options.selectedSources);
-    const buffer = await buildZipBuffer(group, selectedSources);
-    const {
-      client,
-      projectId,
-      contributionTypeSlug,
-      contributionTitle,
-      contributionBody,
-      zipFilename,
-      autoSubmit
-    } = this.opts;
-    const contribution = await client.createContribution(projectId, {
-      contributionTypeSlug,
-      title: contributionTitle,
-      body: contributionBody
-    });
-    const presigned = await client.createUpload(contribution.id, {
-      originalFilename: zipFilename,
-      mimeType: "application/zip",
-      sizeBytes: buffer.byteLength
-    });
-    appendLog(
-      "info",
-      `uploading ${zipFilename} (${buffer.byteLength} bytes) to presigned URL`
-    );
-    await client.uploadToPresignedUrl(
-      presigned.presignedUrl,
-      presigned.headers,
-      buffer
-    );
-    appendLog("info", `PUT to presigned URL succeeded for ${zipFilename}`);
-    if (autoSubmit) {
-      appendLog("info", `submitting contribution ${contribution.id}`);
-      await client.submitContribution(contribution.id);
-      appendLog("info", `contribution ${contribution.id} submitted`);
-    }
-    return contribution.id;
-  }
-};
-
-// src/pipeline.ts
-import fs8 from "fs";
-import path11 from "path";
-function canonicalizePath(p7) {
-  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(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(path11.sep).filter(Boolean);
-      return s.slice(-depth).join("/") === label;
-    });
-    if (matches.length === 1) return label;
-  }
-  return repoPath;
-}
-async function mergeByRepo(files) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const key = canonicalizePath(file.repoPath);
-    const existing = grouped.get(key);
-    if (existing) {
-      existing.push({ ...file, repoPath: key });
-    } else {
-      grouped.set(key, [{ ...file, repoPath: key }]);
-    }
-  }
-  const allPaths = [...grouped.keys()];
-  const groups = [];
-  for (const [repoPath, groupFiles] of grouped) {
-    const stats = await Promise.all(
-      groupFiles.map((f) => fs8.promises.stat(f.absolutePath).catch(() => null))
-    );
-    let lastModified = /* @__PURE__ */ new Date(0);
-    for (const stat of stats) {
-      if (stat && stat.mtime > lastModified) lastModified = stat.mtime;
-    }
-    const sourceNames = [...new Set(groupFiles.map((f) => f.sourceName))];
-    groups.push({
-      repoPath,
-      label: computeLabel(repoPath, allPaths),
-      files: groupFiles,
-      sourceNames,
-      lastModified
-    });
-  }
-  groups.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
-  return groups.filter((g) => g.files.length > 0);
-}
-async function preloadFiles(group) {
-  const files = await Promise.all(
-    group.files.map(async (file) => {
-      if (file.content) return file;
+var NormalizeMiddleware = class {
+  name = "normalize";
+  async process(group) {
+    const newFiles = [];
+    for (const file of group.files) {
+      newFiles.push(file);
+      if (!file.absolutePath.endsWith(".jsonl")) continue;
+      if (!["claude", "codex", "cursor", "opencode", "copilot-chat"].includes(
+        file.sourceName
+      ))
+        continue;
+      const 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"));
       try {
-        const buf = await fs8.promises.readFile(file.absolutePath);
-        const checkLen = Math.min(buf.length, 8192);
-        for (let i = 0; i < checkLen; i++) {
-          if (buf[i] === 0) {
-            return { ...file, content: buf, isBinary: true };
-          }
-        }
-        return { ...file, content: buf };
+        const trajectory = normalizeContent(
+          file.sourceName,
+          content,
+          sessionId
+        );
+        if (!trajectory) continue;
+        const json = JSON.stringify(
+          excludeNone(trajectory),
+          null,
+          2
+        );
+        const atifPath = file.absolutePath.replace(/\.jsonl$/, ".atif.json");
+        newFiles.push({
+          sourceName: file.sourceName,
+          absolutePath: atifPath,
+          repoPath: file.repoPath,
+          metadata: { ...file.metadata, isAtif: true },
+          content: Buffer.from(json, "utf-8")
+        });
       } catch {
-        return file;
       }
-    })
-  );
-  return { ...group, files };
-}
-async function runPipeline(group, middleware2, output, options, onProgress) {
-  const preloaded = await preloadFiles(group);
-  let processed = preloaded;
-  for (const mw of middleware2) {
-    onProgress?.(`${mw.name} (${processed.files.length} files)`);
-    processed = await mw.process(processed);
+    }
+    return { ...group, files: newFiles };
   }
-  onProgress?.(`Compressing ${processed.files.length} files`);
-  return output.emit(processed, options);
-}
+};
 
 // src/commands/upload.ts
 async function readStdin() {
@@ -12637,17 +13156,17 @@ async function readStdin() {
   }
   return Buffer.concat(chunks).toString("utf-8");
 }
-function sanitize(value) {
+function sanitize2(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
-function formatEpochSeconds(date) {
+function formatEpochSeconds2(date) {
   return String(Math.floor(date.getTime() / 1e3));
 }
 function lineHasAssistant(line) {
   return line.includes('"type":"assistant"') || line.includes('"role":"assistant"') || line.includes('"type":"assistant.');
 }
 async function hasAssistantMessage(transcriptPath) {
-  const stream = fs9.createReadStream(transcriptPath, { encoding: "utf-8" });
+  const stream = fs10.createReadStream(transcriptPath, { encoding: "utf-8" });
   let buffer = "";
   try {
     for await (const chunk of stream) {
@@ -12675,7 +13194,25 @@ function resolveSourceTool(payload) {
   if (payload.hook_event_name === "Stop") return "codex";
   return "claude";
 }
+function summarizePayload(payload) {
+  const sessionId = payload.session_id ?? payload.conversation_id ?? null;
+  const turnId = payload.turn_id ?? null;
+  const cwd = payload.cwd ?? payload.workspace_roots?.[0] ?? null;
+  return JSON.stringify({
+    session_id: sessionId,
+    turn_id: turnId,
+    cwd,
+    hook_event_name: payload.hook_event_name ?? null,
+    tool: payload.tool ?? null,
+    model: payload.model ?? null,
+    permission_mode: payload.permission_mode ?? null,
+    transcript_path_present: !!payload.transcript_path,
+    workspace_roots_count: payload.workspace_roots?.length ?? 0,
+    cursor_version_present: !!payload.cursor_version
+  });
+}
 async function selfHealHook(repoRoot, tool) {
+  if (process.env.HILLCLIMB_SKIP_HOOK_SELF_HEAL === "1") return;
   try {
     const result = await healHookForTool(repoRoot, tool);
     if (result.skipped) {
@@ -12697,7 +13234,7 @@ function resolveCursorTranscriptPath(payload) {
   const workspace = payload.workspace_roots?.[0];
   if (!id || !workspace) return void 0;
   const encoded = workspace.replace(/^\//, "").replace(/\//g, "-");
-  return path12.join(
+  return path13.join(
     os5.homedir(),
     ".cursor",
     "projects",
@@ -12733,9 +13270,9 @@ async function runUploadInner(payload) {
   }
   const { repoRoot, config } = match;
   await selfHealHook(repoRoot, sourceTool);
-  const transcriptResolved = path12.resolve(transcriptPath);
+  const transcriptResolved = path13.resolve(transcriptPath);
   try {
-    const stat = await fs9.promises.stat(transcriptResolved);
+    const stat = await fs10.promises.stat(transcriptResolved);
     if (!stat.isFile()) {
       appendLog(
         "warn",
@@ -12775,13 +13312,13 @@ async function uploadSession(args) {
   };
   const group = {
     repoPath: repoRoot,
-    label: path12.basename(repoRoot),
+    label: path13.basename(repoRoot),
     files: [sourceFile],
     sourceNames: [sourceTool],
     lastModified: now
   };
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path12.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path13.join(repoRoot, n));
   const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
   const mwChain = [];
   if (secretResult.values.size > 0) {
@@ -12806,14 +13343,14 @@ async function uploadSession(args) {
     "copilot-chat": "GitHub Copilot Chat",
     opencode: "opencode"
   };
-  const toolLabel = toolLabels[sourceTool] ?? "Claude";
-  const epochSeconds = formatEpochSeconds(now);
-  const title = `${toolLabel} session ${shortId} \u2014 ${epochSeconds}`;
+  const toolLabel2 = toolLabels[sourceTool] ?? "Claude";
+  const epochSeconds = formatEpochSeconds2(now);
+  const title = `${toolLabel2} session ${shortId} \u2014 ${epochSeconds}`;
   const body = `Session ID: ${sessionId}
-Tool: ${toolLabel}
+Tool: ${toolLabel2}
 Repo: ${repoRoot}
 Uploaded: ${now.toISOString()}`;
-  const zipFilename = `${sourceTool}-${sanitize(shortId)}-${epochSeconds}.zip`;
+  const zipFilename = `${sourceTool}-${sanitize2(shortId)}-${epochSeconds}.zip`;
   const output = new PlatformUploadOutput({
     client,
     projectId: config.projectId,
@@ -12929,7 +13466,6 @@ async function runUploadWorker() {
     appendLog("warn", "worker: invoked with empty stdin; payload expected.");
     return;
   }
-  appendLog("info", `worker: raw payload: ${raw.trim()}`);
   let payload;
   try {
     payload = JSON.parse(raw);
@@ -12942,6 +13478,7 @@ async function runUploadWorker() {
   }
   const toolOverride = process.env[TOOL_ENV_FLAG];
   if (toolOverride) payload.tool = toolOverride;
+  appendLog("info", `worker: payload summary: ${summarizePayload(payload)}`);
   try {
     await runUploadInner(payload);
   } catch (err) {
@@ -12949,21 +13486,28 @@ async function runUploadWorker() {
       "error",
       `worker: unexpected error: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
     );
+  } finally {
+    await recordDebugLogCompletion({
+      kind: "agent",
+      tool: resolveSourceTool(payload),
+      payload
+    });
   }
 }
 
 // src/git-traces/index.ts
 import { spawn as spawn3 } from "child_process";
-import crypto2 from "crypto";
+import crypto3 from "crypto";
 
 // src/git-traces/handlers.ts
 import { execFileSync as execFileSync2 } from "child_process";
+import path16 from "path";
 
 // src/git-traces/git-ops.ts
 import { execFileSync } from "child_process";
-import fs10 from "fs";
+import fs11 from "fs";
 import os6 from "os";
-import path13 from "path";
+import path14 from "path";
 import { gzipSync } from "zlib";
 var GIT_COMMAND_TIMEOUT_MS = 12e4;
 var EXEC_OPTS = {
@@ -13087,7 +13631,7 @@ function buildUntrackedTree(repoRoot) {
   for (const relPath of list.split("\0")) {
     if (!relPath) continue;
     try {
-      const stat = fs10.lstatSync(path13.join(repoRoot, relPath));
+      const stat = fs11.lstatSync(path14.join(repoRoot, relPath));
       if (stat.size > MAX_UNTRACKED_FILE_BYTES) {
         appendLog(
           "warn",
@@ -13100,7 +13644,7 @@ function buildUntrackedTree(repoRoot) {
     }
   }
   if (kept.length === 0) return null;
-  const tmpIndex = path13.join(
+  const tmpIndex = path14.join(
     os6.tmpdir(),
     `hillclimb-untracked-${Date.now()}-${process.pid}`
   );
@@ -13113,7 +13657,7 @@ function buildUntrackedTree(repoRoot) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs10.unlinkSync(tmpIndex);
+      fs11.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -13124,7 +13668,7 @@ function buildSnapshotTree(repoRoot, stashSha) {
   if (!untrackedTree || untrackedTree === EMPTY_TREE_SHA) {
     return trackedTree;
   }
-  const tmpIndex = path13.join(
+  const tmpIndex = path14.join(
     os6.tmpdir(),
     `hillclimb-index-${Date.now()}-${process.pid}`
   );
@@ -13152,7 +13696,7 @@ function buildSnapshotTree(repoRoot, stashSha) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs10.unlinkSync(tmpIndex);
+      fs11.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -13166,16 +13710,16 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
   ]);
   const orphanRef = `refs/hillclimb/bundle/${sessionId}`;
   pinRef(repoRoot, orphanRef, orphanCommit);
-  const tmpFile = path13.join(
+  const tmpFile = path14.join(
     os6.tmpdir(),
     `hillclimb-bundle-${Date.now()}.bundle`
   );
   try {
     git(repoRoot, ["bundle", "create", tmpFile, orphanRef]);
-    return fs10.readFileSync(tmpFile);
+    return fs11.readFileSync(tmpFile);
   } finally {
     try {
-      fs10.unlinkSync(tmpFile);
+      fs11.unlinkSync(tmpFile);
     } catch {
     }
     deleteRef(repoRoot, orphanRef);
@@ -13212,12 +13756,34 @@ function detectTransitionKind(repoRoot, prevHeadSha, nextHeadSha) {
     return "branch-switch";
   }
 }
+function parseDirtyFilesFromStatus(status) {
+  const raw = Buffer.isBuffer(status) ? status.toString("utf-8") : status;
+  if (!raw) return [];
+  if (raw.includes("\0")) {
+    const fields = raw.split("\0").filter(Boolean);
+    const dirtyFiles = [];
+    for (let i = 0; i < fields.length; i++) {
+      const record = fields[i];
+      if (record.length < 4) continue;
+      const statusCode = record.slice(0, 2);
+      dirtyFiles.push(record.slice(3));
+      if (statusCode.includes("R") || statusCode.includes("C")) i++;
+    }
+    return dirtyFiles;
+  }
+  return raw.split("\n").filter(Boolean).map((line) => {
+    const match = /^(..) (.*)$/.exec(line);
+    const pathPart = match ? match[2] : line.trim();
+    if (pathPart.includes(" -> ")) return pathPart.split(" -> ").at(-1) ?? "";
+    return pathPart;
+  }).filter(Boolean);
+}
 function buildBaselineMetadata(repoRoot, sessionId, tool, baselineSha, cliVersion, epoch, prevHeadSha, transitionKind, startedAt) {
   const headSha = safeGit(repoRoot, ["rev-parse", "HEAD"]) ?? "unknown";
   const branch = safeGit(repoRoot, ["rev-parse", "--abbrev-ref", "HEAD"]) ?? null;
   const remoteUrl = safeGit(repoRoot, ["config", "--get", "remote.origin.url"]) ?? null;
-  const statusRaw = safeGit(repoRoot, ["status", "--porcelain"]) ?? "";
-  const dirtyFiles = statusRaw.split("\n").filter(Boolean).map((line) => line.slice(3));
+  const statusRaw = safeGitBuffer(repoRoot, ["status", "--porcelain=v1", "-z"]) ?? Buffer.alloc(0);
+  const dirtyFiles = parseDirtyFilesFromStatus(statusRaw);
   const authorName = safeGit(repoRoot, ["config", "user.name"]) ?? "";
   const authorEmail = safeGit(repoRoot, ["config", "user.email"]) ?? "";
   const commits = transitionKind === "commit" && prevHeadSha && headSha !== "unknown" ? enumerateCommits(repoRoot, prevHeadSha, headSha) : void 0;
@@ -13328,9 +13894,9 @@ function parseCommitFiles(repoRoot, sha) {
         oldPath
       });
     } else {
-      const path21 = parts[parts.length - 1];
-      indexByPath.set(path21, files.length);
-      files.push({ path: path21, status, additions: 0, deletions: 0 });
+      const path23 = parts[parts.length - 1];
+      indexByPath.set(path23, files.length);
+      files.push({ path: path23, status, additions: 0, deletions: 0 });
     }
   }
   for (const line of numstat.split("\n")) {
@@ -13361,6 +13927,19 @@ function safeGit(repoRoot, args) {
     return null;
   }
 }
+function safeGitBuffer(repoRoot, args) {
+  try {
+    return gitBuffer(repoRoot, args);
+  } catch (err) {
+    if (isGitTimeoutError(err)) {
+      appendLog(
+        "warn",
+        `git-traces: optional metadata command skipped: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return null;
+  }
+}
 function cleanupSessionRefs(repoRoot, sessionId) {
   for (const prefix of [
     `refs/hillclimb/baseline/${sessionId}`,
@@ -13383,27 +13962,31 @@ function cleanupSessionRefs(repoRoot, sessionId) {
 }
 
 // src/git-traces/session-state.ts
-import crypto from "crypto";
-import fs11 from "fs";
+import crypto2 from "crypto";
+import fs12 from "fs";
 import os7 from "os";
-import path14 from "path";
-var CURRENT_SCHEMA_VERSION = 3;
-var STATE_DIR = path14.join(os7.homedir(), ".hillclimb", "git-traces");
-function stateFileForRepo(repoRoot, tool) {
-  const hash = crypto.createHash("sha256").update(`${path14.resolve(repoRoot)}\0${tool}`).digest("hex").slice(0, 16);
-  return path14.join(STATE_DIR, `${hash}.json`);
+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;
+}
+function stateFileForRepo(repoRoot, tool, sessionId) {
+  const hash = crypto2.createHash("sha256").update(
+    sessionId ? `${path15.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path15.resolve(repoRoot)}\0${tool}`
+  ).digest("hex").slice(0, 16);
+  return path15.join(stateDir2(), `${hash}.json`);
 }
 function lockFileForRepo(repoRoot, tool) {
   return `${stateFileForRepo(repoRoot, tool)}.lock`;
 }
-async function readSessionState(repoRoot, tool) {
+async function readStateFile(file) {
   try {
-    const raw = await fs11.promises.readFile(
-      stateFileForRepo(repoRoot, tool),
-      "utf-8"
-    );
+    const raw = await fs12.promises.readFile(file, "utf-8");
     const parsed = JSON.parse(raw);
-    if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION) {
+    if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION2) {
       return null;
     }
     return parsed;
@@ -13411,29 +13994,117 @@ async function readSessionState(repoRoot, tool) {
     return null;
   }
 }
+async function listScopedSessionStates(repoRoot, tool) {
+  let entries;
+  try {
+    entries = await fs12.promises.readdir(stateDir2(), { 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 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))) {
+      continue;
+    }
+    let mtimeMs = 0;
+    try {
+      mtimeMs = (await fs12.promises.stat(file)).mtimeMs;
+    } catch {
+      continue;
+    }
+    states.push({ state, mtimeMs });
+  }
+  return states;
+}
+async function listSessionStatesForSession(tool, sessionId) {
+  let entries;
+  try {
+    entries = await fs12.promises.readdir(stateDir2(), { 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 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))) {
+      continue;
+    }
+    let mtimeMs = 0;
+    try {
+      mtimeMs = (await fs12.promises.stat(file)).mtimeMs;
+    } catch {
+      continue;
+    }
+    states.push({ state, mtimeMs });
+  }
+  return states;
+}
+async function readSessionState(repoRoot, tool, sessionId) {
+  if (sessionId) {
+    const scoped = await readStateFile(
+      stateFileForRepo(repoRoot, tool, sessionId)
+    );
+    if (scoped) return scoped;
+    const legacy = await readStateFile(stateFileForRepo(repoRoot, tool));
+    return legacy?.sessionId === sessionId ? legacy : null;
+  }
+  return readStateFile(stateFileForRepo(repoRoot, tool));
+}
 async function writeSessionState(state, tool) {
-  const file = stateFileForRepo(state.repoRoot, tool);
-  await fs11.promises.mkdir(STATE_DIR, { recursive: true, mode: 448 });
+  const file = stateFileForRepo(state.repoRoot, tool, state.sessionId);
+  await fs12.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
   const tmp = `${file}.tmp`;
-  await fs11.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+  await fs12.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
     mode: 384
   });
-  await fs11.promises.rename(tmp, file);
+  await fs12.promises.rename(tmp, file);
+  const legacyFile = stateFileForRepo(state.repoRoot, tool);
+  const legacy = await readStateFile(legacyFile);
+  if (legacy?.sessionId === state.sessionId) {
+    await deleteStateFile(legacyFile);
+  }
 }
-async function deleteSessionState(repoRoot, tool) {
+async function deleteStateFile(file) {
   try {
-    await fs11.promises.unlink(stateFileForRepo(repoRoot, tool));
+    await fs12.promises.unlink(file);
   } catch {
   }
 }
-async function acquireLock(repoRoot, tool, retries = 3, delayMs = 200) {
+async function deleteSessionState(repoRoot, tool, sessionId) {
+  if (sessionId) {
+    await deleteStateFile(stateFileForRepo(repoRoot, tool, sessionId));
+    const legacyFile = stateFileForRepo(repoRoot, tool);
+    const legacy = await readStateFile(legacyFile);
+    if (legacy?.sessionId === sessionId) {
+      await deleteStateFile(legacyFile);
+    }
+    return;
+  }
+  await deleteStateFile(stateFileForRepo(repoRoot, tool));
+}
+async function acquireLock2(repoRoot, tool, retries = LOCK_RETRIES2, delayMs = LOCK_RETRY_DELAY_MS2) {
   const lockPath = lockFileForRepo(repoRoot, tool);
-  await fs11.promises.mkdir(STATE_DIR, { recursive: true, mode: 448 });
+  await fs12.promises.mkdir(stateDir2(), { recursive: true, mode: 448 });
   for (let i = 0; i < retries; i++) {
     try {
-      const fd = await fs11.promises.open(
+      const fd = await fs12.promises.open(
         lockPath,
-        fs11.constants.O_CREAT | fs11.constants.O_EXCL | fs11.constants.O_WRONLY
+        fs12.constants.O_CREAT | fs12.constants.O_EXCL | fs12.constants.O_WRONLY
       );
       await fd.write(String(process.pid));
       await fd.close();
@@ -13448,9 +14119,9 @@ async function acquireLock(repoRoot, tool, retries = 3, delayMs = 200) {
   }
   throw new Error(`Failed to acquire lock after ${retries} retries`);
 }
-async function releaseLock(repoRoot, tool) {
+async function releaseLock2(repoRoot, tool) {
   try {
-    await fs11.promises.unlink(lockFileForRepo(repoRoot, tool));
+    await fs12.promises.unlink(lockFileForRepo(repoRoot, tool));
   } catch {
   }
 }
@@ -13459,7 +14130,8 @@ async function releaseLock(repoRoot, tool) {
 var CLI_VERSION = "0.2.0";
 var GIT_TRACES_SLUG = "git-traces";
 var MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
-function formatEpochSeconds2(date) {
+var STALE_SCOPED_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
+function formatEpochSeconds3(date) {
   return String(Math.floor(date.getTime() / 1e3));
 }
 var TOOL_LABELS = {
@@ -13469,10 +14141,20 @@ var TOOL_LABELS = {
   "copilot-chat": "GitHub Copilot Chat",
   opencode: "opencode"
 };
-function resolveCwd(payload) {
+async function loadConfiguredRepos() {
+  const file = await loadProjects();
+  return Object.entries(file.projects).map(([repoRoot, config]) => ({
+    repoRoot: path16.resolve(repoRoot),
+    config
+  })).sort((a, b) => a.repoRoot.localeCompare(b.repoRoot));
+}
+function repoLabel(repoRoot) {
+  return path16.basename(repoRoot) || repoRoot;
+}
+function resolveCwd2(payload) {
   return payload.cwd ?? payload.workspace_roots?.[0] ?? null;
 }
-function resolveSessionId(payload) {
+function resolveSessionId2(payload) {
   return payload.session_id ?? payload.conversation_id ?? null;
 }
 function epochPrefix(epoch) {
@@ -13528,27 +14210,43 @@ function canUploadEpochBaselineArtifacts(epoch, artifacts) {
 }
 function pinEpochBaseline(repoRoot, sessionId, epoch) {
   const baselineSha = captureBaselineSha(repoRoot);
+  const baselineRefPrefix = `refs/hillclimb/baseline/${sessionId}/${epochPrefix(epoch)}`;
+  deleteRef(repoRoot, baselineRefPrefix);
+  pinRef(repoRoot, `${baselineRefPrefix}/tracked`, baselineSha);
+  return { baselineSha, headSha: captureHeadSha(repoRoot) };
+}
+function pinFrozenBaselineTree(repoRoot, sessionId, epoch, baselineTreeSha) {
+  const prefix = epochPrefix(epoch);
+  const commit = execGit(repoRoot, [
+    "commit-tree",
+    baselineTreeSha,
+    "-m",
+    `frozen baseline ${prefix} for session ${sessionId}`
+  ]);
   pinRef(
     repoRoot,
-    `refs/hillclimb/baseline/${sessionId}/${epochPrefix(epoch)}`,
-    baselineSha
+    `refs/hillclimb/baseline/${sessionId}/${prefix}/tree`,
+    commit
   );
-  return { baselineSha, headSha: captureHeadSha(repoRoot) };
 }
-function buildEpochBaselineArtifacts(params) {
+function freezeEpochBaseline(params) {
   const {
     repoRoot,
     sessionId,
     tool,
     epoch,
-    baselineSha,
     prevHeadSha,
     transitionKind,
     startedAt
   } = params;
   const prefix = epochPrefix(epoch);
   try {
-    const metadata = buildBaselineMetadata(
+    const { baselineSha, headSha } = pinEpochBaseline(
+      repoRoot,
+      sessionId,
+      epoch
+    );
+    const baselineMetadata = buildBaselineMetadata(
       repoRoot,
       sessionId,
       tool,
@@ -13560,13 +14258,29 @@ function buildEpochBaselineArtifacts(params) {
       startedAt
     );
     const baselineTreeSha = buildSnapshotTree(repoRoot, baselineSha);
+    pinFrozenBaselineTree(repoRoot, sessionId, epoch, baselineTreeSha);
+    return { baselineSha, baselineTreeSha, baselineMetadata, headSha };
+  } catch (err) {
+    appendLog(
+      "error",
+      `git-traces: failed to freeze baseline for ${prefix}: ${formatError(err)}`
+    );
+    return null;
+  }
+}
+function buildFrozenEpochBaselineArtifacts(params) {
+  const { repoRoot, sessionId, epoch, baselineTreeSha, baselineMetadata } = params;
+  const prefix = epochPrefix(epoch);
+  try {
     const bundleBuffer = createBundleFromTree(
       repoRoot,
       baselineTreeSha,
       `${sessionId}-${prefix}`,
       `baseline ${prefix}`
     );
-    const metadataBuffer = Buffer.from(JSON.stringify(metadata, null, 2));
+    const metadataBuffer = Buffer.from(
+      JSON.stringify(baselineMetadata, null, 2)
+    );
     return { baselineTreeSha, metadataBuffer, bundleBuffer };
   } catch (err) {
     appendLog(
@@ -13576,6 +14290,46 @@ function buildEpochBaselineArtifacts(params) {
     return null;
   }
 }
+function buildEpochBaselineArtifacts(params) {
+  const {
+    repoRoot,
+    sessionId,
+    tool,
+    epoch,
+    baselineSha,
+    prevHeadSha,
+    transitionKind,
+    startedAt
+  } = params;
+  const prefix = epochPrefix(epoch);
+  try {
+    const metadata = buildBaselineMetadata(
+      repoRoot,
+      sessionId,
+      tool,
+      baselineSha,
+      CLI_VERSION,
+      epoch,
+      prevHeadSha,
+      transitionKind,
+      startedAt
+    );
+    const baselineTreeSha = buildSnapshotTree(repoRoot, baselineSha);
+    return buildFrozenEpochBaselineArtifacts({
+      repoRoot,
+      sessionId,
+      epoch,
+      baselineTreeSha,
+      baselineMetadata: metadata
+    });
+  } catch (err) {
+    appendLog(
+      "error",
+      `git-traces: failed to build baseline artifacts for ${prefix}: ${formatError(err)}`
+    );
+    return null;
+  }
+}
 async function uploadEpochBaselineArtifacts(params) {
   const { client, contributionId, epoch, artifacts } = params;
   const prefix = epochPrefix(epoch);
@@ -13596,6 +14350,34 @@ async function uploadEpochBaselineArtifacts(params) {
     artifacts.metadataBuffer
   );
 }
+async function createGitTracesContribution(params) {
+  const { client, config, repoRoot, state, tool, now, artifacts } = params;
+  const toolLabel2 = TOOL_LABELS[tool] ?? "Claude";
+  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}
+Tool: ${toolLabel2}
+Repo: ${repoRoot}
+Uploaded: ${now.toISOString()}`
+  });
+  const uploaded = await uploadEpochBaselineArtifacts({
+    client,
+    contributionId: contribution.id,
+    epoch: 1,
+    artifacts
+  });
+  if (!uploaded) return null;
+  await client.submitContribution(contribution.id);
+  appendLog(
+    "info",
+    `git-traces: baseline uploaded (repo=${repoRoot}, project=${config.projectId}, contribution=${contribution.id}, epoch=1, bundleBytes=${artifacts.bundleBuffer.byteLength}, metadataBytes=${artifacts.metadataBuffer.byteLength})`
+  );
+  return contribution.id;
+}
 async function uploadEpochBaseline(params) {
   const artifacts = buildEpochBaselineArtifacts(params);
   if (!artifacts) return null;
@@ -13619,161 +14401,263 @@ async function openEpoch(params) {
   if (!uploaded) return null;
   return { baselineSha, baselineTreeSha: uploaded.baselineTreeSha, headSha };
 }
-async function initializeSession(cwd, tool, sessionId) {
-  const project = await findProjectForCwd(cwd);
-  if (!project) {
-    appendLog(
-      "warn",
-      "git-traces: no hillclimb project config found, skipping"
-    );
-    return null;
-  }
-  const { baselineSha, headSha } = pinEpochBaseline(cwd, sessionId, 1);
+async function initializeSession(repoRoot, tool, sessionId) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const frozen = freezeEpochBaseline({
+    repoRoot,
+    sessionId,
+    tool,
+    epoch: 1,
+    prevHeadSha: null,
+    transitionKind: "initial",
+    startedAt
+  });
+  if (!frozen) return null;
   const state = {
-    schemaVersion: CURRENT_SCHEMA_VERSION,
+    schemaVersion: CURRENT_SCHEMA_VERSION2,
     sessionId,
     contributionId: null,
-    baselineSha,
-    baselineTreeSha: null,
-    lastSnapshotSha: baselineSha,
-    lastSnapshotTreeSha: null,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    baselineSha: frozen.baselineSha,
+    baselineTreeSha: frozen.baselineTreeSha,
+    baselineMetadata: frozen.baselineMetadata,
+    lastSnapshotSha: frozen.baselineSha,
+    lastSnapshotTreeSha: frozen.baselineTreeSha,
+    startedAt,
     epoch: 1,
     turnCount: 0,
-    headSha,
-    repoRoot: cwd
+    headSha: frozen.headSha,
+    repoRoot
   };
   await writeSessionState(state, tool);
   appendLog(
     "info",
-    `git-traces: session pending (baseline=${baselineSha.slice(0, 8)}, awaiting first turn)`
+    `git-traces: session pending (repo=${repoRoot}, baseline=${frozen.baselineSha.slice(0, 8)}, awaiting first turn)`
   );
   return state;
 }
+async function cleanupStaleScopedSessionStates(repoRoot, tool, currentSessionId, options = {}) {
+  const nowMs = options.nowMs ?? Date.now();
+  const ttlMs = options.ttlMs ?? STALE_SCOPED_STATE_TTL_MS;
+  const states = await listScopedSessionStates(repoRoot, tool);
+  let removed = 0;
+  for (const { state, mtimeMs } of states) {
+    if (state.sessionId === currentSessionId) continue;
+    const startedAtMs = Date.parse(state.startedAt);
+    const ageBaseMs = Number.isNaN(startedAtMs) ? mtimeMs : startedAtMs;
+    if (nowMs - ageBaseMs <= ttlMs) continue;
+    appendLog(
+      "info",
+      `git-traces: cleaning up stale scoped session ${state.sessionId}`
+    );
+    cleanupSessionRefs(repoRoot, state.sessionId);
+    await deleteSessionState(repoRoot, tool, state.sessionId);
+    removed++;
+  }
+  return removed;
+}
+async function processSessionStartRepo(repo, tool, sessionId) {
+  const { repoRoot } = repo;
+  if (!isGitRepo(repoRoot)) {
+    appendLog(
+      "info",
+      `git-traces: skipping repo on SessionStart (repo=${repoRoot}, reason=not-git-repo)`
+    );
+    return "skipped";
+  }
+  await acquireLock2(repoRoot, tool);
+  try {
+    const staleLegacy = await readSessionState(repoRoot, tool);
+    if (staleLegacy && staleLegacy.sessionId !== sessionId) {
+      appendLog(
+        "info",
+        `git-traces: cleaning up stale session ${staleLegacy.sessionId} (repo=${repoRoot})`
+      );
+      cleanupSessionRefs(repoRoot, staleLegacy.sessionId);
+      await deleteSessionState(repoRoot, tool);
+    }
+    const staleCount = await cleanupStaleScopedSessionStates(
+      repoRoot,
+      tool,
+      sessionId
+    );
+    if (staleCount > 0) {
+      appendLog(
+        "info",
+        `git-traces: cleaned stale scoped sessions (repo=${repoRoot}, count=${staleCount})`
+      );
+    }
+    const state = await initializeSession(repoRoot, tool, sessionId);
+    return state ? "initialized" : "failed";
+  } catch (err) {
+    appendLog(
+      "error",
+      `git-traces: SessionStart failed for repo ${repoRoot}: ${formatError(err)}`
+    );
+    return "failed";
+  } finally {
+    await releaseLock2(repoRoot, tool);
+  }
+}
 async function handleSessionStart(payload, tool) {
-  const cwd = resolveCwd(payload);
+  const cwd = resolveCwd2(payload);
   if (!cwd) {
     appendLog("warn", "git-traces: no cwd in payload, skipping");
     return;
   }
-  if (!isGitRepo(cwd)) {
-    appendLog("info", "git-traces: not a git repo, skipping");
+  const startingProject = await findProjectForCwd(cwd);
+  if (!startingProject) {
+    appendLog(
+      "warn",
+      "git-traces: no hillclimb project config found, skipping"
+    );
     return;
   }
-  const sessionId = resolveSessionId(payload);
+  const sessionId = resolveSessionId2(payload);
   if (!sessionId) {
     appendLog("warn", "git-traces: no session_id in payload, skipping");
     return;
   }
-  await acquireLock(cwd, tool);
-  try {
-    const stale = await readSessionState(cwd, tool);
-    if (stale && stale.sessionId !== sessionId) {
-      appendLog(
-        "info",
-        `git-traces: cleaning up stale session ${stale.sessionId}`
-      );
-      cleanupSessionRefs(cwd, stale.sessionId);
-      await deleteSessionState(cwd, tool);
-    }
-    await initializeSession(cwd, tool, sessionId);
-  } finally {
-    await releaseLock(cwd, tool);
+  const repos = await loadConfiguredRepos();
+  let initialized = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const repo of repos) {
+    const outcome = await processSessionStartRepo(repo, tool, sessionId);
+    if (outcome === "initialized") initialized++;
+    else if (outcome === "skipped") skipped++;
+    else failed++;
   }
+  appendLog(
+    "info",
+    `git-traces: SessionStart summary (session=${sessionId}, tool=${tool}, triggerRepo=${startingProject.repoRoot}, configured=${repos.length}, initialized=${initialized}, skipped=${skipped}, failed=${failed})`
+  );
 }
-async function handleStop(payload, tool) {
-  const cwd = resolveCwd(payload);
-  if (!cwd) return;
-  if (!isGitRepo(cwd)) return;
-  const recordedAt = Date.now();
-  await acquireLock(cwd, tool);
-  try {
-    const state = await readSessionState(cwd, tool);
-    if (!state) return;
-    const project = await findProjectForCwd(cwd);
-    if (!project) return;
-    const identity = await loadIdentity(project.config.apiBaseUrl);
-    if (!identity) {
-      appendLog(
-        "warn",
-        `git-traces: no saved login for ${project.config.apiBaseUrl}, skipping epoch close`
-      );
-      return;
-    }
-    const client = new PlatformClient(
-      project.config.apiBaseUrl,
-      identity.sessionCookie
+function buildInitialBaselineArtifactsForState(repoRoot, tool, state) {
+  if (state.baselineTreeSha && state.baselineMetadata) {
+    return buildFrozenEpochBaselineArtifacts({
+      repoRoot,
+      sessionId: state.sessionId,
+      epoch: 1,
+      baselineTreeSha: state.baselineTreeSha,
+      baselineMetadata: state.baselineMetadata
+    });
+  }
+  return buildEpochBaselineArtifacts({
+    repoRoot,
+    sessionId: state.sessionId,
+    tool,
+    epoch: 1,
+    baselineSha: state.baselineSha,
+    prevHeadSha: null,
+    transitionKind: "initial",
+    startedAt: state.startedAt
+  });
+}
+async function loadRepoClient(repo) {
+  const identity = await loadIdentity(repo.config.apiBaseUrl);
+  if (!identity) {
+    appendLog(
+      "warn",
+      `git-traces: skipping repo on Stop (repo=${repo.repoRoot}, project=${repo.config.projectId}, reason=no-saved-login, apiBaseUrl=${repo.config.apiBaseUrl})`
     );
-    if (state.contributionId === null) {
-      const artifacts = buildEpochBaselineArtifacts({
-        repoRoot: cwd,
-        sessionId: state.sessionId,
-        tool,
-        epoch: 1,
-        baselineSha: state.baselineSha,
-        prevHeadSha: null,
-        transitionKind: "initial",
-        startedAt: state.startedAt
-      });
-      if (!artifacts) return;
-      if (!canUploadEpochBaselineArtifacts(1, artifacts)) return;
-      const toolLabel = TOOL_LABELS[tool] ?? "Claude";
-      const now = /* @__PURE__ */ new Date();
-      const epochSeconds = formatEpochSeconds2(now);
-      const shortId = state.sessionId.slice(0, 12);
-      const contribution = await client.createContribution(
-        project.config.projectId,
-        {
-          contributionTypeSlug: GIT_TRACES_SLUG,
-          title: `${toolLabel} session ${shortId} \u2014 ${epochSeconds}`,
-          body: `Session ID: ${state.sessionId}
-Tool: ${toolLabel}
-Repo: ${cwd}
-Uploaded: ${now.toISOString()}`
-        }
-      );
-      const uploaded = await uploadEpochBaselineArtifacts({
-        client,
-        contributionId: contribution.id,
-        epoch: 1,
-        artifacts
-      });
-      if (!uploaded) return;
-      await client.submitContribution(contribution.id);
-      state.contributionId = contribution.id;
-      state.baselineTreeSha = artifacts.baselineTreeSha;
-      state.lastSnapshotTreeSha = artifacts.baselineTreeSha;
-      await writeSessionState(state, tool);
+    return null;
+  }
+  return new PlatformClient(repo.config.apiBaseUrl, identity.sessionCookie);
+}
+async function registerInitialContribution(params) {
+  const { repo, state, tool, client, artifacts } = params;
+  const contributionId = await createGitTracesContribution({
+    client,
+    config: repo.config,
+    repoRoot: repo.repoRoot,
+    state,
+    tool,
+    now: /* @__PURE__ */ new Date(),
+    artifacts
+  });
+  if (!contributionId) return false;
+  state.contributionId = contributionId;
+  state.baselineTreeSha = artifacts.baselineTreeSha;
+  state.lastSnapshotTreeSha = artifacts.baselineTreeSha;
+  await writeSessionState(state, tool);
+  appendLog(
+    "info",
+    `git-traces: session registered on first changed turn (repo=${repo.repoRoot}, project=${repo.config.projectId}, contribution=${contributionId}, epoch=1, baseline=${state.baselineSha.slice(0, 8)})`
+  );
+  return true;
+}
+async function processStopRepo(repo, tool, sessionId, recordedAt) {
+  const { repoRoot, config } = repo;
+  if (!isGitRepo(repoRoot)) {
+    appendLog(
+      "info",
+      `git-traces: skipping repo on Stop (repo=${repoRoot}, project=${config.projectId}, reason=not-git-repo)`
+    );
+    return "skipped";
+  }
+  await acquireLock2(repoRoot, tool);
+  let state = null;
+  try {
+    state = await readSessionState(repoRoot, tool, sessionId);
+    if (!state) {
       appendLog(
         "info",
-        `git-traces: session registered on first turn (epoch=1, baseline=${state.baselineSha.slice(0, 8)}, contribution=${contribution.id})`
+        `git-traces: skipping repo on Stop (repo=${repoRoot}, project=${config.projectId}, reason=no-active-state)`
       );
+      return "no-state";
     }
-    const contributionId = state.contributionId;
-    const lastSnapshotTreeSha = state.lastSnapshotTreeSha;
-    if (contributionId === null || lastSnapshotTreeSha === null) {
+    const lastSnapshotTreeSha = state.lastSnapshotTreeSha ?? state.baselineTreeSha;
+    if (!lastSnapshotTreeSha) {
       appendLog(
         "error",
-        "git-traces: invariant violation \u2014 session state missing contributionId or tree SHA after lazy init"
+        `git-traces: invariant violation \u2014 session state missing snapshot tree SHA (repo=${repoRoot}, session=${state.sessionId})`
       );
-      return;
+      return "failed";
     }
-    const currentHeadSha = captureHeadSha(cwd);
+    const currentHeadSha = captureHeadSha(repoRoot);
     if (currentHeadSha !== state.headSha) {
+      const client2 = await loadRepoClient(repo);
+      if (!client2) return "skipped";
+      if (state.contributionId === null) {
+        const artifacts2 = buildInitialBaselineArtifactsForState(
+          repoRoot,
+          tool,
+          state
+        );
+        if (!artifacts2 || !canUploadEpochBaselineArtifacts(1, artifacts2)) {
+          return "skipped";
+        }
+        const registered = await registerInitialContribution({
+          repo,
+          state,
+          tool,
+          client: client2,
+          artifacts: artifacts2
+        });
+        if (!registered) return "failed";
+      }
+      const contributionId2 = state.contributionId;
+      if (contributionId2 === null) {
+        appendLog(
+          "error",
+          `git-traces: invariant violation \u2014 missing contribution after registration (repo=${repoRoot}, session=${state.sessionId})`
+        );
+        return "failed";
+      }
       const transitionKind = detectTransitionKind(
-        cwd,
+        repoRoot,
         state.headSha || null,
         currentHeadSha
       );
       const nextEpoch = state.epoch + 1;
       appendLog(
         "info",
-        `git-traces: HEAD moved (${transitionKind}, ${state.headSha.slice(0, 8)} \u2192 ${currentHeadSha.slice(0, 8)}), opening epoch ${nextEpoch}`
+        `git-traces: HEAD moved (repo=${repoRoot}, project=${config.projectId}, contribution=${contributionId2}, transition=${transitionKind}, from=${state.headSha.slice(0, 8)}, to=${currentHeadSha.slice(0, 8)}, openingEpoch=${nextEpoch})`
       );
       const artifacts = await openEpoch({
-        repoRoot: cwd,
-        client,
-        contributionId,
+        repoRoot,
+        client: client2,
+        contributionId: contributionId2,
         sessionId: state.sessionId,
         tool,
         epoch: nextEpoch,
@@ -13781,7 +14665,7 @@ Uploaded: ${now.toISOString()}`
         transitionKind,
         startedAt: state.startedAt
       });
-      if (!artifacts) return;
+      if (!artifacts) return "failed";
       const next = {
         ...state,
         baselineSha: artifacts.baselineSha,
@@ -13793,65 +14677,228 @@ Uploaded: ${now.toISOString()}`
         headSha: artifacts.headSha
       };
       await writeSessionState(next, tool);
-      return;
+      appendLog(
+        "info",
+        `git-traces: epoch baseline uploaded (repo=${repoRoot}, project=${config.projectId}, contribution=${contributionId2}, epoch=${nextEpoch}, baseline=${artifacts.baselineSha.slice(0, 8)})`
+      );
+      return "uploaded";
     }
-    const currentSha = captureSnapshotSha(cwd);
-    const currentTreeSha = buildSnapshotTree(cwd, currentSha);
+    const currentSha = captureSnapshotSha(repoRoot);
+    const currentTreeSha = buildSnapshotTree(repoRoot, currentSha);
     const patchBuffer = createTreeDiffPatchGz(
-      cwd,
+      repoRoot,
       lastSnapshotTreeSha,
       currentTreeSha
     );
     if (!patchBuffer) {
       appendLog(
         "info",
-        "git-traces: turn produced identical snapshot tree, skipping upload"
+        `git-traces: turn produced identical snapshot tree, skipping upload (repo=${repoRoot}, project=${config.projectId})`
       );
-      return;
+      return "unchanged";
     }
-    state.turnCount++;
     const prefix = epochPrefix(state.epoch);
-    const turnLabel = turnSuffix(state.turnCount);
+    const nextTurnCount = state.turnCount + 1;
+    const turnLabel = turnSuffix(nextTurnCount);
+    const filename = `${prefix}-${turnLabel}-${recordedAt}.patch.gz`;
+    if (state.contributionId === null && !canUploadFile(filename, patchBuffer)) {
+      appendLog(
+        "warn",
+        `git-traces: first changed turn skipped before contribution creation (repo=${repoRoot}, project=${config.projectId}, reason=patch-too-large)`
+      );
+      return "skipped";
+    }
+    const client = await loadRepoClient(repo);
+    if (!client) return "skipped";
+    if (state.contributionId === null) {
+      const artifacts = buildInitialBaselineArtifactsForState(
+        repoRoot,
+        tool,
+        state
+      );
+      if (!artifacts || !canUploadEpochBaselineArtifacts(1, artifacts)) {
+        return "skipped";
+      }
+      const registered = await registerInitialContribution({
+        repo,
+        state,
+        tool,
+        client,
+        artifacts
+      });
+      if (!registered) return "failed";
+    }
+    const contributionId = state.contributionId;
+    if (contributionId === null) {
+      appendLog(
+        "error",
+        `git-traces: invariant violation \u2014 missing contribution before patch upload (repo=${repoRoot}, session=${state.sessionId})`
+      );
+      return "failed";
+    }
     pinRef(
-      cwd,
+      repoRoot,
       `refs/hillclimb/turns/${state.sessionId}/${prefix}/${turnLabel}`,
       currentSha
     );
-    const filename = `${prefix}-${turnLabel}-${recordedAt}.patch.gz`;
-    await uploadFile(
+    const uploaded = await uploadFile(
       client,
       contributionId,
       filename,
       "application/gzip",
       patchBuffer
     );
+    if (!uploaded) {
+      appendLog(
+        "warn",
+        `git-traces: ${prefix}-${turnLabel} not uploaded; keeping last uploaded snapshot unchanged (repo=${repoRoot}, project=${config.projectId}, contribution=${contributionId})`
+      );
+      return "skipped";
+    }
+    state.turnCount = nextTurnCount;
     state.lastSnapshotSha = currentSha;
     state.lastSnapshotTreeSha = currentTreeSha;
     await writeSessionState(state, tool);
     appendLog(
       "info",
-      `git-traces: ${prefix}-${turnLabel} uploaded (${patchBuffer.byteLength} bytes)`
+      `git-traces: patch uploaded (repo=${repoRoot}, project=${config.projectId}, contribution=${contributionId}, epoch=${state.epoch}, turn=${turnLabel}, bytes=${patchBuffer.byteLength})`
+    );
+    return "uploaded";
+  } catch (err) {
+    appendLog(
+      "error",
+      `git-traces: Stop failed for repo ${repoRoot}: ${formatError(err)}`
     );
+    if (state && err instanceof PlatformError && err.status === 404 && err.code === "CONTRIBUTION_NOT_FOUND") {
+      if (state.baselineTreeSha) {
+        await writeSessionState(
+          {
+            ...state,
+            contributionId: null,
+            lastSnapshotSha: state.baselineSha,
+            lastSnapshotTreeSha: state.baselineTreeSha,
+            turnCount: 0
+          },
+          tool
+        );
+        appendLog(
+          "warn",
+          `git-traces: cleared stale contribution state (repo=${repoRoot}, project=${config.projectId}, missingContribution=${state.contributionId})`
+        );
+      } else {
+        cleanupSessionRefs(repoRoot, state.sessionId);
+        await deleteSessionState(repoRoot, tool, state.sessionId);
+        appendLog(
+          "warn",
+          `git-traces: deleted stale contribution state without a frozen baseline (repo=${repoRoot}, project=${config.projectId}, missingContribution=${state.contributionId})`
+        );
+      }
+    }
+    return "failed";
   } finally {
-    await releaseLock(cwd, tool);
+    await releaseLock2(repoRoot, tool);
   }
 }
-async function handleSessionEnd(payload, tool) {
-  const cwd = resolveCwd(payload);
+async function handleStop(payload, tool) {
+  const cwd = resolveCwd2(payload);
   if (!cwd) return;
-  await acquireLock(cwd, tool);
+  const project = await findProjectForCwd(cwd);
+  if (!project) return;
+  const sessionId = resolveSessionId2(payload);
+  const recordedAt = Date.now();
+  const repos = await loadConfiguredRepos();
+  const repoByRoot = new Map(repos.map((repo) => [repo.repoRoot, repo]));
+  const targets = [];
+  let missingConfig = 0;
+  if (sessionId) {
+    const storedStates = await listSessionStatesForSession(tool, sessionId);
+    for (const { state } of storedStates) {
+      const repo = repoByRoot.get(path16.resolve(state.repoRoot));
+      if (!repo) {
+        missingConfig++;
+        appendLog(
+          "warn",
+          `git-traces: skipping repo on Stop (repo=${state.repoRoot}, session=${sessionId}, reason=missing-config)`
+        );
+        continue;
+      }
+      targets.push(repo);
+    }
+    if (targets.length === 0 && missingConfig === 0) {
+      targets.push({ repoRoot: project.repoRoot, config: project.config });
+    }
+  } else {
+    targets.push({ repoRoot: project.repoRoot, config: project.config });
+  }
+  let uploaded = 0;
+  let unchanged = 0;
+  let skipped = missingConfig;
+  let noState = 0;
+  let failed = 0;
+  for (const repo of targets) {
+    const outcome = await processStopRepo(repo, tool, sessionId, recordedAt);
+    if (outcome === "uploaded") uploaded++;
+    else if (outcome === "unchanged") unchanged++;
+    else if (outcome === "skipped") skipped++;
+    else if (outcome === "no-state") noState++;
+    else failed++;
+  }
+  appendLog(
+    "info",
+    `git-traces: Stop summary (session=${sessionId ?? "<none>"}, tool=${tool}, triggerRepo=${project.repoRoot}, configured=${repos.length}, frozenStates=${targets.length + missingConfig}, uploaded=${uploaded}, unchanged=${unchanged}, skipped=${skipped}, noState=${noState}, failed=${failed})`
+  );
+}
+async function cleanupSessionStateForRepo(repoRoot, tool, sessionId) {
+  await acquireLock2(repoRoot, tool);
   try {
-    const state = await readSessionState(cwd, tool);
-    if (!state) return;
-    cleanupSessionRefs(cwd, state.sessionId);
-    await deleteSessionState(cwd, tool);
+    const state = await readSessionState(repoRoot, tool, sessionId);
+    if (!state) return "no-state";
+    cleanupSessionRefs(repoRoot, state.sessionId);
+    await deleteSessionState(repoRoot, tool, state.sessionId);
     appendLog(
       "info",
-      `git-traces: session ${state.sessionId} cleaned up (${state.epoch} epoch(s), last had ${state.turnCount} turns)`
+      `git-traces: session ${state.sessionId} cleaned up (repo=${repoRoot}, epochCount=${state.epoch}, lastTurnCount=${state.turnCount})`
+    );
+    return "cleaned";
+  } catch (err) {
+    appendLog(
+      "error",
+      `git-traces: SessionEnd cleanup failed for repo ${repoRoot}: ${formatError(err)}`
     );
+    return "failed";
   } finally {
-    await releaseLock(cwd, tool);
+    await releaseLock2(repoRoot, tool);
+  }
+}
+async function handleSessionEnd(payload, tool) {
+  const cwd = resolveCwd2(payload);
+  const sessionId = resolveSessionId2(payload);
+  const project = cwd ? await findProjectForCwd(cwd) : null;
+  const triggerRepo = project?.repoRoot ?? cwd ?? "<none>";
+  const repoRoots = [];
+  if (sessionId) {
+    const states = await listSessionStatesForSession(tool, sessionId);
+    for (const { state } of states) {
+      repoRoots.push(path16.resolve(state.repoRoot));
+    }
+  }
+  if (repoRoots.length === 0 && cwd) {
+    repoRoots.push(project?.repoRoot ?? cwd);
+  }
+  if (repoRoots.length === 0) return;
+  let cleaned = 0;
+  let noState = 0;
+  let failed = 0;
+  for (const repoRoot of repoRoots) {
+    const outcome = await cleanupSessionStateForRepo(repoRoot, tool, sessionId);
+    if (outcome === "cleaned") cleaned++;
+    else if (outcome === "no-state") noState++;
+    else failed++;
   }
+  appendLog(
+    "info",
+    `git-traces: SessionEnd summary (session=${sessionId ?? "<none>"}, tool=${tool}, triggerRepo=${triggerRepo}, states=${repoRoots.length}, cleaned=${cleaned}, noState=${noState}, failed=${failed})`
+  );
 }
 
 // src/git-traces/index.ts
@@ -13859,7 +14906,7 @@ var WORKER_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_WORKER";
 var TOOL_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_TOOL";
 var FLOW_ID_ENV = "HILLCLIMB_GIT_TRACES_FLOW";
 function newFlowId() {
-  return crypto2.randomBytes(3).toString("hex");
+  return crypto3.randomBytes(3).toString("hex");
 }
 var KNOWN_TOOLS = /* @__PURE__ */ new Set([
   "claude",
@@ -13868,6 +14915,25 @@ var KNOWN_TOOLS = /* @__PURE__ */ new Set([
   "cursor",
   "opencode"
 ]);
+function classifyHookEvent2(event) {
+  switch (event) {
+    case "SessionStart":
+    case "sessionStart":
+    case "session.created":
+      return "sessionStart";
+    case "Stop":
+    case "stop":
+    case "session.idle":
+      return "stop";
+    case "SessionEnd":
+    case "sessionEnd":
+    case "session.deleted":
+    case "server.instance.disposed":
+      return "sessionEnd";
+    default:
+      return "unknown";
+  }
+}
 function parseToolArg2(argv) {
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -13884,28 +14950,94 @@ async function readStdin2() {
   }
   return Buffer.concat(chunks).toString("utf-8");
 }
-function resolveCwd2(payload) {
+function resolveCwd3(payload) {
   return payload.cwd ?? payload.workspace_roots?.[0] ?? null;
 }
+async function repairHookForTool(repoRoot, tool) {
+  const result = await healHookForTool(repoRoot, tool);
+  if (result.skipped) {
+    appendLog("warn", `self-heal: skipped ${tool} hook (${result.skipped})`);
+    return;
+  }
+  if (result.changed) {
+    appendLog("info", `self-heal: updated ${tool} hook`);
+  }
+}
 async function selfHealHook2(payload, tool) {
-  const cwd = resolveCwd2(payload);
+  if (process.env.HILLCLIMB_SKIP_HOOK_SELF_HEAL === "1") return;
+  const cwd = resolveCwd3(payload);
   if (!cwd) return;
   try {
     const project = await findProjectForCwd(cwd);
     if (!project) return;
-    const result = await healHookForTool(project.repoRoot, tool);
-    if (result.skipped) {
-      appendLog("warn", `self-heal: skipped ${tool} hook (${result.skipped})`);
-      return;
+    await repairHookForTool(project.repoRoot, tool);
+  } catch (err) {
+    appendLog(
+      "warn",
+      `self-heal: failed to repair ${tool} hook: ${formatError(err)}`
+    );
+  }
+}
+async function resolveLegacyBareTool(raw) {
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch (err) {
+    appendLog(
+      "error",
+      `git-traces: missing --tool and failed to parse payload for legacy hook repair: ${formatError(err)}`
+    );
+    return null;
+  }
+  const cwd = resolveCwd3(payload);
+  if (!cwd) {
+    appendLog(
+      "error",
+      "git-traces: missing --tool and no cwd in payload for legacy hook repair"
+    );
+    return null;
+  }
+  try {
+    const project = await findProjectForCwd(cwd);
+    if (!project) {
+      appendLog(
+        "error",
+        `git-traces: missing --tool and no hillclimb config for cwd ${cwd}`
+      );
+      return null;
     }
-    if (result.changed) {
-      appendLog("info", `self-heal: updated ${tool} hook`);
+    const owners = await findLegacyGitTracesHookOwners(
+      project.repoRoot,
+      payload.hook_event_name
+    );
+    if (owners.length === 0) {
+      appendLog(
+        "error",
+        `git-traces: missing --tool and no legacy bare git-traces hook matched event ${payload.hook_event_name ?? "<none>"}`
+      );
+      return null;
+    }
+    for (const owner of owners) {
+      await repairHookForTool(project.repoRoot, owner);
+    }
+    if (owners.length > 1) {
+      appendLog(
+        "warn",
+        `git-traces: legacy bare hook matched multiple tools (${owners.join(", ")}); repaired hooks but skipped this event`
+      );
+      return null;
     }
+    appendLog(
+      "info",
+      `git-traces: inferred legacy bare hook owner ${owners[0]} and repaired hook`
+    );
+    return owners[0];
   } catch (err) {
     appendLog(
       "warn",
-      `self-heal: failed to repair ${tool} hook: ${formatError(err)}`
+      `git-traces: failed legacy hook repair: ${formatError(err)}`
     );
+    return null;
   }
 }
 async function runGitTraces() {
@@ -13920,13 +15052,6 @@ async function runGitTraces() {
     "info",
     `git-traces hook invoked (pid ${process.pid}, tool=${toolArg ?? "<none>"})`
   );
-  if (!toolArg || !KNOWN_TOOLS.has(toolArg)) {
-    appendLog(
-      "error",
-      `git-traces: missing or unknown --tool arg (got ${toolArg ?? "<none>"})`
-    );
-    return;
-  }
   let raw;
   try {
     raw = await readStdin2();
@@ -13938,6 +15063,15 @@ async function runGitTraces() {
     appendLog("warn", "git-traces: empty stdin, expected hook payload");
     return;
   }
+  let tool = toolArg;
+  if (tool && !KNOWN_TOOLS.has(tool)) {
+    appendLog("error", `git-traces: unknown --tool arg (got ${tool})`);
+    return;
+  }
+  if (!tool) {
+    tool = await resolveLegacyBareTool(raw);
+    if (!tool) return;
+  }
   const entrypoint = process.argv[1];
   if (!entrypoint) {
     appendLog("error", "git-traces: process.argv[1] is empty");
@@ -13946,14 +15080,14 @@ async function runGitTraces() {
   try {
     const child = spawn3(
       process.execPath,
-      [entrypoint, "git-traces", `--tool=${toolArg}`],
+      [entrypoint, "git-traces", `--tool=${tool}`],
       {
         detached: true,
         stdio: ["pipe", "ignore", "ignore"],
         env: {
           ...process.env,
           [WORKER_ENV_FLAG2]: "1",
-          [TOOL_ENV_FLAG2]: toolArg,
+          [TOOL_ENV_FLAG2]: tool,
           [FLOW_ID_ENV]: flowId
         }
       }
@@ -14014,6 +15148,7 @@ async function runGitTracesWorker() {
     return;
   }
   const event = payload.hook_event_name;
+  const eventKind = classifyHookEvent2(event);
   appendLog("info", `git-traces worker: handling event=${event}`);
   if (tool === "claude" && typeof payload.cursor_version === "string") {
     appendLog(
@@ -14022,27 +15157,16 @@ async function runGitTracesWorker() {
     );
     return;
   }
-  await selfHealHook2(payload, tool);
   try {
-    switch (event) {
-      case "SessionStart":
+    await selfHealHook2(payload, tool);
+    switch (eventKind) {
       case "sessionStart":
-      // opencode: session.created fires when a new session is first opened.
-      case "session.created":
         await handleSessionStart(payload, tool);
         break;
-      case "Stop":
       case "stop":
-      // opencode: session.idle fires at end-of-turn (agent finished responding).
-      case "session.idle":
         await handleStop(payload, tool);
         break;
-      case "SessionEnd":
       case "sessionEnd":
-      // opencode: server.instance.disposed fires when opencode shuts down.
-      // Payload has `cwd` (from the plugin) but no session_id; handleSessionEnd
-      // reads state by (repoRoot, tool), so cwd alone is sufficient for cleanup.
-      case "server.instance.disposed":
         await handleSessionEnd(payload, tool);
         break;
       default:
@@ -14056,19 +15180,27 @@ async function runGitTracesWorker() {
       `git-traces worker: unexpected error: ${detail}${stack ? `
 ${stack}` : ""}`
     );
+  } finally {
+    if (eventKind === "stop" || eventKind === "sessionEnd") {
+      await recordDebugLogCompletion({
+        kind: "git",
+        tool,
+        payload
+      });
+    }
   }
 }
 
 // src/outputs/zip.ts
-import fs13 from "fs";
-import path16 from "path";
+import fs14 from "fs";
+import path18 from "path";
 import archiver2 from "archiver";
 
 // src/outputs/downloads.ts
 import { execSync as execSync2 } from "child_process";
-import fs12 from "fs";
+import fs13 from "fs";
 import os8 from "os";
-import path15 from "path";
+import path17 from "path";
 function getDownloadsFolder() {
   const home = os8.homedir();
   if (process.platform === "linux") {
@@ -14077,12 +15209,12 @@ function getDownloadsFolder() {
         encoding: "utf-8",
         timeout: 3e3
       }).trim();
-      if (xdgDir && fs12.existsSync(xdgDir)) return xdgDir;
+      if (xdgDir && fs13.existsSync(xdgDir)) return xdgDir;
     } catch {
     }
   }
-  const downloads = path15.join(home, "Downloads");
-  if (fs12.existsSync(downloads)) return downloads;
+  const downloads = path17.join(home, "Downloads");
+  if (fs13.existsSync(downloads)) return downloads;
   return home;
 }
 
@@ -14091,11 +15223,11 @@ function sanitizeFilename(name) {
   return name.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function getUniqueFilename(dir, base, ext) {
-  let candidate = path16.join(dir, `${base}${ext}`);
-  if (!fs13.existsSync(candidate)) return candidate;
+  let candidate = path18.join(dir, `${base}${ext}`);
+  if (!fs14.existsSync(candidate)) return candidate;
   let i = 1;
-  while (fs13.existsSync(candidate)) {
-    candidate = path16.join(dir, `${base}-${i}${ext}`);
+  while (fs14.existsSync(candidate)) {
+    candidate = path18.join(dir, `${base}-${i}${ext}`);
     i++;
   }
   return candidate;
@@ -14105,13 +15237,13 @@ var ZipOutput = class {
   label = "Save as .zip to Downloads";
   async emit(group, options) {
     const downloadsDir = getDownloadsFolder();
-    const repoName = sanitizeFilename(path16.basename(group.repoPath));
+    const repoName = sanitizeFilename(path18.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 = fs13.createWriteStream(outputPath);
+    const output = fs14.createWriteStream(outputPath);
     const archive = archiver2("zip", { zlib: { level: 6 } });
     const done = new Promise((resolve, reject) => {
       output.on("close", resolve);
@@ -14305,15 +15437,15 @@ async function confirmExport(group, output) {
 }
 
 // src/sources/claude.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import os9 from "os";
-import path17 from "path";
+import path19 from "path";
 import readline from "readline";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["tool-results"]);
 async function resolveRepoPath(projectDir) {
-  const indexPath = path17.join(projectDir, "sessions-index.json");
+  const indexPath = path19.join(projectDir, "sessions-index.json");
   try {
-    const raw = await fs14.promises.readFile(indexPath, "utf-8");
+    const raw = await fs15.promises.readFile(indexPath, "utf-8");
     const data = JSON.parse(raw);
     if (data.originalPath && typeof data.originalPath === "string") {
       return data.originalPath;
@@ -14321,12 +15453,12 @@ async function resolveRepoPath(projectDir) {
   } catch {
   }
   const cwdCounts = /* @__PURE__ */ new Map();
-  const entries = await fs14.promises.readdir(projectDir, {
+  const entries = await fs15.promises.readdir(projectDir, {
     withFileTypes: true
   });
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-    const cwd = await extractCwdFromJsonl(path17.join(projectDir, entry.name));
+    const cwd = await extractCwdFromJsonl(path19.join(projectDir, entry.name));
     if (cwd) {
       cwdCounts.set(cwd, (cwdCounts.get(cwd) ?? 0) + 1);
     }
@@ -14345,7 +15477,7 @@ async function resolveRepoPath(projectDir) {
   return null;
 }
 async function extractCwdFromJsonl(filePath) {
-  const stream = fs14.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs15.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -14367,12 +15499,12 @@ async function extractCwdFromJsonl(filePath) {
 async function collectFiles(dir, baseDir, sourceName, repoPath, results) {
   let entries;
   try {
-    entries = await fs14.promises.readdir(dir, { withFileTypes: true });
+    entries = await fs15.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path17.join(dir, entry.name);
+    const fullPath = path19.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
       await collectFiles(fullPath, baseDir, sourceName, repoPath, results);
@@ -14394,19 +15526,19 @@ function fallbackDecode(encodedName) {
 var ClaudeSource = class {
   name = "claude";
   async scan() {
-    const baseDir = path17.join(os9.homedir(), ".claude", "projects");
+    const baseDir = path19.join(os9.homedir(), ".claude", "projects");
     try {
-      await fs14.promises.access(baseDir);
+      await fs15.promises.access(baseDir);
     } catch {
       return [];
     }
-    const projectDirs = await fs14.promises.readdir(baseDir, {
+    const projectDirs = await fs15.promises.readdir(baseDir, {
       withFileTypes: true
     });
     const dirEntries = projectDirs.filter((d) => d.isDirectory());
     const resultArrays = await Promise.all(
       dirEntries.map(async (dir) => {
-        const projectPath = path17.join(baseDir, dir.name);
+        const projectPath = path19.join(baseDir, dir.name);
         const repoPath = await resolveRepoPath(projectPath) ?? fallbackDecode(dir.name);
         const files = [];
         await collectFiles(
@@ -14424,12 +15556,12 @@ var ClaudeSource = class {
 };
 
 // src/sources/codex.ts
-import fs15 from "fs";
+import fs16 from "fs";
 import os10 from "os";
-import path18 from "path";
+import path20 from "path";
 import readline2 from "readline";
 async function parseSessionMeta(filePath) {
-  const stream = fs15.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs16.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -14454,12 +15586,12 @@ async function findJsonlFiles(dir) {
   async function walk(d) {
     let entries;
     try {
-      entries = await fs15.promises.readdir(d, { withFileTypes: true });
+      entries = await fs16.promises.readdir(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path18.join(d, entry.name);
+      const full = path20.join(d, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -14473,11 +15605,11 @@ async function findJsonlFiles(dir) {
 async function loadHistory(historyPath) {
   const map = /* @__PURE__ */ new Map();
   try {
-    await fs15.promises.access(historyPath);
+    await fs16.promises.access(historyPath);
   } catch {
     return map;
   }
-  const stream = fs15.createReadStream(historyPath, { encoding: "utf-8" });
+  const stream = fs16.createReadStream(historyPath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -14504,14 +15636,14 @@ async function loadHistory(historyPath) {
 var CodexSource = class {
   name = "codex";
   async scan() {
-    const codexDir = path18.join(os10.homedir(), ".codex");
-    const sessionsDir = path18.join(codexDir, "sessions");
+    const codexDir = path20.join(os10.homedir(), ".codex");
+    const sessionsDir = path20.join(codexDir, "sessions");
     try {
-      await fs15.promises.access(sessionsDir);
+      await fs16.promises.access(sessionsDir);
     } catch {
       return [];
     }
-    const historyPath = path18.join(codexDir, "history.jsonl");
+    const historyPath = path20.join(codexDir, "history.jsonl");
     const [jsonlFiles, historyMap] = await Promise.all([
       findJsonlFiles(sessionsDir),
       loadHistory(historyPath)
@@ -14534,8 +15666,8 @@ var CodexSource = class {
       });
       const historyLines = historyMap.get(meta.sessionId);
       if (historyLines) {
-        const sessionDir = path18.relative(sessionsDir, path18.dirname(filePath));
-        const historyAbsPath = path18.join(
+        const sessionDir = path20.relative(sessionsDir, path20.dirname(filePath));
+        const historyAbsPath = path20.join(
           sessionsDir,
           sessionDir,
           `history-${meta.sessionId}.jsonl`
@@ -14555,18 +15687,18 @@ var CodexSource = class {
 };
 
 // src/sources/copilotChat.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import os11 from "os";
-import path19 from "path";
+import path21 from "path";
 import { fileURLToPath } from "url";
 function vsCodeUserDirs() {
   const home = os11.homedir();
   const dirs = [
-    path19.join(home, "Library", "Application Support", "Code", "User"),
-    path19.join(home, ".config", "Code", "User")
+    path21.join(home, "Library", "Application Support", "Code", "User"),
+    path21.join(home, ".config", "Code", "User")
   ];
   if (process.env.APPDATA) {
-    dirs.push(path19.join(process.env.APPDATA, "Code", "User"));
+    dirs.push(path21.join(process.env.APPDATA, "Code", "User"));
   }
   return dirs;
 }
@@ -14581,7 +15713,7 @@ function uriToFsPath(uri) {
 async function readWorkspaceFolder(workspaceJsonPath) {
   let raw;
   try {
-    raw = await fs16.promises.readFile(workspaceJsonPath, "utf-8");
+    raw = await fs17.promises.readFile(workspaceJsonPath, "utf-8");
   } catch {
     return null;
   }
@@ -14603,10 +15735,10 @@ var CopilotChatSource = class {
   async scan() {
     const results = [];
     for (const userDir of vsCodeUserDirs()) {
-      const workspaceStorage = path19.join(userDir, "workspaceStorage");
+      const workspaceStorage = path21.join(userDir, "workspaceStorage");
       let hashDirs;
       try {
-        hashDirs = await fs16.promises.readdir(workspaceStorage, {
+        hashDirs = await fs17.promises.readdir(workspaceStorage, {
           withFileTypes: true
         });
       } catch {
@@ -14614,22 +15746,22 @@ var CopilotChatSource = class {
       }
       for (const hash of hashDirs) {
         if (!hash.isDirectory()) continue;
-        const wsRoot = path19.join(workspaceStorage, hash.name);
-        const transcriptsDir = path19.join(
+        const wsRoot = path21.join(workspaceStorage, hash.name);
+        const transcriptsDir = path21.join(
           wsRoot,
           "GitHub.copilot-chat",
           "transcripts"
         );
         let transcriptEntries;
         try {
-          transcriptEntries = await fs16.promises.readdir(transcriptsDir, {
+          transcriptEntries = await fs17.promises.readdir(transcriptsDir, {
             withFileTypes: true
           });
         } catch {
           continue;
         }
         const repoPath = await readWorkspaceFolder(
-          path19.join(wsRoot, "workspace.json")
+          path21.join(wsRoot, "workspace.json")
         );
         if (!repoPath) continue;
         for (const entry of transcriptEntries) {
@@ -14637,7 +15769,7 @@ var CopilotChatSource = class {
           const sessionId = entry.name.slice(0, -".jsonl".length);
           results.push({
             sourceName: this.name,
-            absolutePath: path19.join(transcriptsDir, entry.name),
+            absolutePath: path21.join(transcriptsDir, entry.name),
             repoPath,
             metadata: { sessionId }
           });
@@ -14677,7 +15809,7 @@ function reportRedactionStats(noun, stats) {
 async function filterByTimeRange(group, range) {
   const results = await Promise.all(
     group.files.map(
-      (f) => fs17.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
+      (f) => fs18.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
     )
   );
   const filtered = [];
@@ -14704,10 +15836,10 @@ async function runInteractive() {
   s.start(`Scanning ${source.name} logs...`);
   const allFiles = await source.scan();
   const allGroups = await mergeByRepo(allFiles);
-  const repoRoot = path20.resolve(repo.root);
+  const repoRoot = path22.resolve(repo.root);
   const matching = allGroups.filter((g) => {
-    const resolved = path20.resolve(g.repoPath);
-    return resolved === repoRoot || resolved.startsWith(repoRoot + path20.sep);
+    const resolved = path22.resolve(g.repoPath);
+    return resolved === repoRoot || resolved.startsWith(repoRoot + path22.sep);
   });
   if (matching.length === 0) {
     s.stop(`No ${source.name} logs found for ${repo.name}.`);
@@ -14738,7 +15870,7 @@ async function runInteractive() {
     }
   }
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path20.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path22.join(repoRoot, n));
   const additionalFiles = await promptSecretFiles(envFileNames);
   const secretResult = await collectSecrets(
     repoRoot,