hillclimb 0.3.0 → 0.4.1

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs17 from "fs";
-import path21 from "path";
+import fs18 from "fs";
+import path22 from "path";
 import * as p6 from "@clack/prompts";
 
 // src/commands/init.ts
@@ -2149,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";
@@ -10844,161 +10849,732 @@ 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;
+};
+
+// 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);
   }
-  if (metadata !== void 0) {
-    if (!("raw_tool_result" in metadata)) {
-      metadata.raw_tool_result = block;
-    }
+  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;
   }
-  const resultText = parts.filter(Boolean).join("\n\n").trim();
-  return [resultText || void 0, metadata];
+  return repoPath;
 }
-function convertClaudeToTrajectory(jsonlContent, sessionId) {
-  const rawEvents = [];
-  for (const line of jsonlContent.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      rawEvents.push(JSON.parse(trimmed));
-    } catch {
+async function 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 }]);
     }
   }
-  if (rawEvents.length === 0) return null;
-  const events = rawEvents.sort(
-    (a, b) => (a.timestamp ?? "").localeCompare(b.timestamp ?? "")
-  );
-  if (events.length === 0) return null;
+  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 = [];
+  for (const line of jsonlContent.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      rawEvents.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  if (rawEvents.length === 0) return null;
+  const events = rawEvents.sort(
+    (a, b) => (a.timestamp ?? "").localeCompare(b.timestamp ?? "")
+  );
+  if (events.length === 0) return null;
   let sid = sessionId ?? "";
   for (const event of events) {
     if (typeof event.sessionId === "string") {
@@ -12470,288 +13046,106 @@ function convertRunEventsToTrajectory(events, sessionId) {
     agent: {
       name: "opencode",
       version: "unknown"
-    },
-    steps,
-    final_metrics: finalMetricsFromSteps2(steps)
-  };
-}
-function isRunEvent(lines) {
-  return lines.some(
-    (line) => ["step_start", "step_finish", "text", "reasoning", "tool_use"].includes(
-      String(line.type ?? "")
-    )
-  );
-}
-function convertOpenCodeToTrajectory(content, sessionId) {
-  const trimmed = content.trim();
-  if (!trimmed) return null;
-  try {
-    const parsed = JSON.parse(trimmed);
-    const parsedObj = asObject3(parsed);
-    const messages = asArray(parsedObj?.messages);
-    if (parsedObj && messages.length > 0) {
-      const entries2 = messages.flatMap((message) => {
-        const entry = entryFromLine(asObject3(message) ?? {});
-        return entry ? [entry] : [];
-      });
-      return convertMessageEntriesToTrajectory(
-        entries2,
-        sessionId,
-        asObject3(parsedObj.info)
-      );
-    }
-  } catch {
-  }
-  const lines = parseJsonLines2(content);
-  if (lines.length === 0) return null;
-  if (isRunEvent(lines)) return convertRunEventsToTrajectory(lines, sessionId);
-  const wrappedEntries = entriesFromEventWrappers(lines);
-  const entries = wrappedEntries.length > 0 ? wrappedEntries : lines.flatMap((line) => {
-    const entry = entryFromLine(line);
-    return entry ? [entry] : [];
-  });
-  return convertMessageEntriesToTrajectory(entries, sessionId);
-}
-
-// src/normalizer/index.ts
-function normalizeContent(sourceName, content, sessionId) {
-  switch (sourceName) {
-    case "claude":
-      return convertClaudeToTrajectory(content, sessionId);
-    case "codex":
-      return convertCodexToTrajectory(content, sessionId);
-    case "cursor":
-      return convertCursorToTrajectory(content, sessionId);
-    case "opencode":
-      return convertOpenCodeToTrajectory(content, sessionId);
-    case "copilot-chat":
-      return convertCopilotChatToTrajectory(content, sessionId);
-    default:
-      return null;
-  }
-}
-var NormalizeMiddleware = class {
-  name = "normalize";
-  async process(group) {
-    const newFiles = [];
-    for (const file of group.files) {
-      newFiles.push(file);
-      if (!file.absolutePath.endsWith(".jsonl")) continue;
-      if (!["claude", "codex", "cursor", "opencode", "copilot-chat"].includes(
-        file.sourceName
-      ))
-        continue;
-      const content = file.content ? file.content.toString("utf-8") : null;
-      if (!content) continue;
-      const sessionId = file.metadata?.sessionId ?? (file.sourceName === "codex" ? void 0 : 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;
+    },
+    steps,
+    final_metrics: finalMetricsFromSteps2(steps)
+  };
 }
-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 }]);
+function isRunEvent(lines) {
+  return lines.some(
+    (line) => ["step_start", "step_finish", "text", "reasoning", "tool_use"].includes(
+      String(line.type ?? "")
+    )
+  );
+}
+function convertOpenCodeToTrajectory(content, sessionId) {
+  const trimmed = content.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    const parsedObj = asObject3(parsed);
+    const messages = asArray(parsedObj?.messages);
+    if (parsedObj && messages.length > 0) {
+      const entries2 = messages.flatMap((message) => {
+        const entry = entryFromLine(asObject3(message) ?? {});
+        return entry ? [entry] : [];
+      });
+      return convertMessageEntriesToTrajectory(
+        entries2,
+        sessionId,
+        asObject3(parsedObj.info)
+      );
     }
+  } catch {
   }
-  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
-    });
+  const lines = parseJsonLines2(content);
+  if (lines.length === 0) return null;
+  if (isRunEvent(lines)) return convertRunEventsToTrajectory(lines, sessionId);
+  const wrappedEntries = entriesFromEventWrappers(lines);
+  const entries = wrappedEntries.length > 0 ? wrappedEntries : lines.flatMap((line) => {
+    const entry = entryFromLine(line);
+    return entry ? [entry] : [];
+  });
+  return convertMessageEntriesToTrajectory(entries, sessionId);
+}
+
+// src/normalizer/index.ts
+function normalizeContent(sourceName, content, sessionId) {
+  switch (sourceName) {
+    case "claude":
+      return convertClaudeToTrajectory(content, sessionId);
+    case "codex":
+      return convertCodexToTrajectory(content, sessionId);
+    case "cursor":
+      return convertCursorToTrajectory(content, sessionId);
+    case "opencode":
+      return convertOpenCodeToTrajectory(content, sessionId);
+    case "copilot-chat":
+      return convertCopilotChatToTrajectory(content, sessionId);
+    default:
+      return null;
   }
-  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() {
@@ -12762,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) {
@@ -12800,6 +13194,23 @@ 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 {
@@ -12823,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",
@@ -12859,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",
@@ -12901,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) {
@@ -12932,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,
@@ -13055,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);
@@ -13068,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) {
@@ -13075,22 +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 path15 from "path";
+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 = {
@@ -13098,7 +13515,7 @@ var EXEC_OPTS = {
   maxBuffer: 50 * 1024 * 1024
 };
 var MAX_ERROR_OUTPUT_CHARS = 2e3;
-var MAX_UNTRACKED_FILE_BYTES = 10 * 1024 * 1024;
+var MAX_SNAPSHOT_FILE_BYTES = 10 * 1024 * 1024;
 var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 function quoteGitArg(arg) {
   if (/^[A-Za-z0-9_./:=@%+,-]+$/.test(arg)) return arg;
@@ -13202,7 +13619,55 @@ function captureSnapshotSha(repoRoot) {
   }
   return git(repoRoot, ["rev-parse", "HEAD"]);
 }
-function buildUntrackedTree(repoRoot) {
+function recordOmittedSnapshotFile(omittedFiles, file) {
+  omittedFiles?.push(file);
+  const action = file.tracked ? "omitting tracked" : "skipping untracked";
+  appendLog(
+    "warn",
+    `git-traces: ${action} ${file.path} (${file.sizeBytes} bytes > ${MAX_SNAPSHOT_FILE_BYTES} limit)`
+  );
+}
+function parseLsTreeLongZ(output) {
+  const entries = [];
+  for (const record of output.toString("utf-8").split("\0")) {
+    if (!record) continue;
+    const tab = record.indexOf("	");
+    if (tab === -1) continue;
+    const meta = record.slice(0, tab);
+    const filePath = record.slice(tab + 1);
+    const [mode, type, sha, sizeRaw] = meta.trim().split(/\s+/);
+    if (type !== "blob" || !mode || !sha || !sizeRaw) continue;
+    const sizeBytes = Number.parseInt(sizeRaw, 10);
+    if (!Number.isFinite(sizeBytes)) continue;
+    entries.push({ mode, sha, sizeBytes, path: filePath });
+  }
+  return entries;
+}
+function listOversizedTreeFiles(repoRoot, treeSha, omittedFiles) {
+  const output = gitBuffer(repoRoot, ["ls-tree", "-r", "-l", "-z", treeSha]);
+  const oversized = [];
+  for (const entry of parseLsTreeLongZ(output)) {
+    if (entry.sizeBytes <= MAX_SNAPSHOT_FILE_BYTES) continue;
+    const file = {
+      path: entry.path,
+      sizeBytes: entry.sizeBytes,
+      tracked: true,
+      reason: "file-over-limit",
+      gitObjectSha: entry.sha
+    };
+    oversized.push(file);
+    recordOmittedSnapshotFile(omittedFiles, file);
+  }
+  return oversized;
+}
+function removePathsFromIndex(repoRoot, env, paths) {
+  if (paths.length === 0) return;
+  gitBuffer(repoRoot, ["update-index", "--force-remove", "-z", "--stdin"], {
+    input: `${paths.join("\0")}\0`,
+    env
+  });
+}
+function buildUntrackedTree(repoRoot, omittedFiles) {
   const list = git(repoRoot, [
     "ls-files",
     "--others",
@@ -13214,12 +13679,14 @@ function buildUntrackedTree(repoRoot) {
   for (const relPath of list.split("\0")) {
     if (!relPath) continue;
     try {
-      const stat = fs10.lstatSync(path13.join(repoRoot, relPath));
-      if (stat.size > MAX_UNTRACKED_FILE_BYTES) {
-        appendLog(
-          "warn",
-          `git-traces: skipping untracked ${relPath} (${stat.size} bytes > ${MAX_UNTRACKED_FILE_BYTES} limit)`
-        );
+      const stat = fs11.lstatSync(path14.join(repoRoot, relPath));
+      if (stat.size > MAX_SNAPSHOT_FILE_BYTES) {
+        recordOmittedSnapshotFile(omittedFiles, {
+          path: relPath,
+          sizeBytes: stat.size,
+          tracked: false,
+          reason: "file-over-limit"
+        });
         continue;
       }
       kept.push(relPath);
@@ -13227,7 +13694,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}`
   );
@@ -13240,46 +13707,58 @@ function buildUntrackedTree(repoRoot) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs10.unlinkSync(tmpIndex);
+      fs11.unlinkSync(tmpIndex);
     } catch {
     }
   }
 }
-function buildSnapshotTree(repoRoot, stashSha) {
+function buildSnapshotTree(repoRoot, stashSha, options = {}) {
   const trackedTree = git(repoRoot, ["rev-parse", `${stashSha}^{tree}`]);
-  const untrackedTree = buildUntrackedTree(repoRoot);
-  if (!untrackedTree || untrackedTree === EMPTY_TREE_SHA) {
+  const oversizedTracked = listOversizedTreeFiles(
+    repoRoot,
+    trackedTree,
+    options.omittedFiles
+  );
+  const untrackedTree = buildUntrackedTree(repoRoot, options.omittedFiles);
+  if (oversizedTracked.length === 0 && (!untrackedTree || untrackedTree === EMPTY_TREE_SHA)) {
     return trackedTree;
   }
-  const tmpIndex = path13.join(
+  const tmpIndex = path14.join(
     os6.tmpdir(),
     `hillclimb-index-${Date.now()}-${process.pid}`
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
   try {
     gitWithEnv(repoRoot, ["read-tree", trackedTree], env);
-    const untrackedList = gitBuffer(
+    removePathsFromIndex(
       repoRoot,
-      ["ls-tree", "-r", untrackedTree],
-      {
-        env
+      env,
+      oversizedTracked.map((file) => file.path)
+    );
+    if (untrackedTree && untrackedTree !== EMPTY_TREE_SHA) {
+      const untrackedList = gitBuffer(
+        repoRoot,
+        ["ls-tree", "-r", untrackedTree],
+        {
+          env
+        }
+      ).toString("utf-8");
+      const indexInfo = untrackedList.split("\n").filter(Boolean).map((line) => {
+        const [meta, filePath] = line.split("	");
+        const [mode, , sha] = meta.split(/\s+/);
+        return `${mode} ${sha}	${filePath}`;
+      }).join("\n");
+      if (indexInfo) {
+        gitBuffer(repoRoot, ["update-index", "--index-info"], {
+          input: indexInfo,
+          env
+        });
       }
-    ).toString("utf-8");
-    const indexInfo = untrackedList.split("\n").filter(Boolean).map((line) => {
-      const [meta, filePath] = line.split("	");
-      const [mode, , sha] = meta.split(/\s+/);
-      return `${mode} ${sha}	${filePath}`;
-    }).join("\n");
-    if (indexInfo) {
-      gitBuffer(repoRoot, ["update-index", "--index-info"], {
-        input: indexInfo,
-        env
-      });
     }
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs10.unlinkSync(tmpIndex);
+      fs11.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -13293,16 +13772,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);
@@ -13361,7 +13840,7 @@ function parseDirtyFilesFromStatus(status) {
     return pathPart;
   }).filter(Boolean);
 }
-function buildBaselineMetadata(repoRoot, sessionId, tool, baselineSha, cliVersion, epoch, prevHeadSha, transitionKind, startedAt) {
+function buildBaselineMetadata(repoRoot, sessionId, tool, baselineSha, cliVersion, epoch, prevHeadSha, transitionKind, startedAt, omittedFiles = []) {
   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;
@@ -13385,7 +13864,8 @@ function buildBaselineMetadata(repoRoot, sessionId, tool, baselineSha, cliVersio
       branch,
       remoteUrl,
       isDirty: dirtyFiles.length > 0,
-      dirtyFiles
+      dirtyFiles,
+      ...omittedFiles.length > 0 ? { omittedFiles } : {}
     },
     author: { name: authorName, email: authorEmail },
     hostname: os6.hostname(),
@@ -13477,9 +13957,9 @@ function parseCommitFiles(repoRoot, sha) {
         oldPath
       });
     } else {
-      const path22 = parts[parts.length - 1];
-      indexByPath.set(path22, files.length);
-      files.push({ path: path22, 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")) {
@@ -13545,31 +14025,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 DEFAULT_STATE_DIR = path14.join(os7.homedir(), ".hillclimb", "git-traces");
-var LOCK_RETRIES = 120;
-var LOCK_RETRY_DELAY_MS = 500;
-function stateDir() {
+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 = crypto.createHash("sha256").update(
-    sessionId ? `${path14.resolve(repoRoot)}\0${tool}\0${sessionId}` : `${path14.resolve(repoRoot)}\0${tool}`
+  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 path14.join(stateDir(), `${hash}.json`);
+  return path15.join(stateDir2(), `${hash}.json`);
 }
 function lockFileForRepo(repoRoot, tool) {
   return `${stateFileForRepo(repoRoot, tool)}.lock`;
 }
 async function readStateFile(file) {
   try {
-    const raw = await fs11.promises.readFile(file, "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;
@@ -13580,26 +14060,26 @@ async function readStateFile(file) {
 async function listScopedSessionStates(repoRoot, tool) {
   let entries;
   try {
-    entries = await fs11.promises.readdir(stateDir(), { withFileTypes: true });
+    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 = path14.join(stateDir(), entry.name);
+    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 (path14.resolve(state.repoRoot) !== path14.resolve(repoRoot)) continue;
-    if (path14.resolve(file) !== path14.resolve(stateFileForRepo(repoRoot, tool, state.sessionId))) {
+    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 fs11.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs12.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -13610,26 +14090,26 @@ async function listScopedSessionStates(repoRoot, tool) {
 async function listSessionStatesForSession(tool, sessionId) {
   let entries;
   try {
-    entries = await fs11.promises.readdir(stateDir(), { withFileTypes: true });
+    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 = path14.join(stateDir(), entry.name);
+    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 (path14.resolve(file) !== path14.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
+    if (path15.resolve(file) !== path15.resolve(stateFileForRepo(state.repoRoot, tool, sessionId))) {
       continue;
     }
     let mtimeMs = 0;
     try {
-      mtimeMs = (await fs11.promises.stat(file)).mtimeMs;
+      mtimeMs = (await fs12.promises.stat(file)).mtimeMs;
     } catch {
       continue;
     }
@@ -13650,12 +14130,12 @@ async function readSessionState(repoRoot, tool, sessionId) {
 }
 async function writeSessionState(state, tool) {
   const file = stateFileForRepo(state.repoRoot, tool, state.sessionId);
-  await fs11.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+  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) {
@@ -13664,7 +14144,7 @@ async function writeSessionState(state, tool) {
 }
 async function deleteStateFile(file) {
   try {
-    await fs11.promises.unlink(file);
+    await fs12.promises.unlink(file);
   } catch {
   }
 }
@@ -13680,14 +14160,14 @@ async function deleteSessionState(repoRoot, tool, sessionId) {
   }
   await deleteStateFile(stateFileForRepo(repoRoot, tool));
 }
-async function acquireLock(repoRoot, tool, retries = LOCK_RETRIES, delayMs = LOCK_RETRY_DELAY_MS) {
+async function acquireLock2(repoRoot, tool, retries = LOCK_RETRIES2, delayMs = LOCK_RETRY_DELAY_MS2) {
   const lockPath = lockFileForRepo(repoRoot, tool);
-  await fs11.promises.mkdir(stateDir(), { 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();
@@ -13702,9 +14182,9 @@ async function acquireLock(repoRoot, tool, retries = LOCK_RETRIES, delayMs = LOC
   }
   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 {
   }
 }
@@ -13714,7 +14194,7 @@ var CLI_VERSION = "0.2.0";
 var GIT_TRACES_SLUG = "git-traces";
 var MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
 var STALE_SCOPED_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
-function formatEpochSeconds2(date) {
+function formatEpochSeconds3(date) {
   return String(Math.floor(date.getTime() / 1e3));
 }
 var TOOL_LABELS = {
@@ -13727,17 +14207,17 @@ var TOOL_LABELS = {
 async function loadConfiguredRepos() {
   const file = await loadProjects();
   return Object.entries(file.projects).map(([repoRoot, config]) => ({
-    repoRoot: path15.resolve(repoRoot),
+    repoRoot: path16.resolve(repoRoot),
     config
   })).sort((a, b) => a.repoRoot.localeCompare(b.repoRoot));
 }
 function repoLabel(repoRoot) {
-  return path15.basename(repoRoot) || repoRoot;
+  return path16.basename(repoRoot) || repoRoot;
 }
-function resolveCwd(payload) {
+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) {
@@ -13829,6 +14309,10 @@ function freezeEpochBaseline(params) {
       sessionId,
       epoch
     );
+    const omittedFiles = [];
+    const baselineTreeSha = buildSnapshotTree(repoRoot, baselineSha, {
+      omittedFiles
+    });
     const baselineMetadata = buildBaselineMetadata(
       repoRoot,
       sessionId,
@@ -13838,9 +14322,9 @@ function freezeEpochBaseline(params) {
       epoch,
       prevHeadSha,
       transitionKind,
-      startedAt
+      startedAt,
+      omittedFiles
     );
-    const baselineTreeSha = buildSnapshotTree(repoRoot, baselineSha);
     pinFrozenBaselineTree(repoRoot, sessionId, epoch, baselineTreeSha);
     return { baselineSha, baselineTreeSha, baselineMetadata, headSha };
   } catch (err) {
@@ -13886,6 +14370,10 @@ function buildEpochBaselineArtifacts(params) {
   } = params;
   const prefix = epochPrefix(epoch);
   try {
+    const omittedFiles = [];
+    const baselineTreeSha = buildSnapshotTree(repoRoot, baselineSha, {
+      omittedFiles
+    });
     const metadata = buildBaselineMetadata(
       repoRoot,
       sessionId,
@@ -13895,9 +14383,9 @@ function buildEpochBaselineArtifacts(params) {
       epoch,
       prevHeadSha,
       transitionKind,
-      startedAt
+      startedAt,
+      omittedFiles
     );
-    const baselineTreeSha = buildSnapshotTree(repoRoot, baselineSha);
     return buildFrozenEpochBaselineArtifacts({
       repoRoot,
       sessionId,
@@ -13935,15 +14423,15 @@ async function uploadEpochBaselineArtifacts(params) {
 }
 async function createGitTracesContribution(params) {
   const { client, config, repoRoot, state, tool, now, artifacts } = params;
-  const toolLabel = TOOL_LABELS[tool] ?? "Claude";
-  const epochSeconds = formatEpochSeconds2(now);
+  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: `${toolLabel} session ${shortId} \u2014 ${repoName} \u2014 ${epochSeconds}`,
+    title: `${toolLabel2} session ${shortId} \u2014 ${repoName} \u2014 ${epochSeconds}`,
     body: `Session ID: ${state.sessionId}
-Tool: ${toolLabel}
+Tool: ${toolLabel2}
 Repo: ${repoRoot}
 Uploaded: ${now.toISOString()}`
   });
@@ -13997,7 +14485,7 @@ async function initializeSession(repoRoot, tool, sessionId) {
   });
   if (!frozen) return null;
   const state = {
-    schemaVersion: CURRENT_SCHEMA_VERSION,
+    schemaVersion: CURRENT_SCHEMA_VERSION2,
     sessionId,
     contributionId: null,
     baselineSha: frozen.baselineSha,
@@ -14047,7 +14535,7 @@ async function processSessionStartRepo(repo, tool, sessionId) {
     );
     return "skipped";
   }
-  await acquireLock(repoRoot, tool);
+  await acquireLock2(repoRoot, tool);
   try {
     const staleLegacy = await readSessionState(repoRoot, tool);
     if (staleLegacy && staleLegacy.sessionId !== sessionId) {
@@ -14078,11 +14566,11 @@ async function processSessionStartRepo(repo, tool, sessionId) {
     );
     return "failed";
   } finally {
-    await releaseLock(repoRoot, tool);
+    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;
@@ -14095,7 +14583,7 @@ async function handleSessionStart(payload, tool) {
     );
     return;
   }
-  const sessionId = resolveSessionId(payload);
+  const sessionId = resolveSessionId2(payload);
   if (!sessionId) {
     appendLog("warn", "git-traces: no session_id in payload, skipping");
     return;
@@ -14178,9 +14666,10 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
     );
     return "skipped";
   }
-  await acquireLock(repoRoot, tool);
+  await acquireLock2(repoRoot, tool);
+  let state = null;
   try {
-    const state = await readSessionState(repoRoot, tool, sessionId);
+    state = await readSessionState(repoRoot, tool, sessionId);
     if (!state) {
       appendLog(
         "info",
@@ -14351,17 +14840,42 @@ async function processStopRepo(repo, tool, sessionId, recordedAt) {
       "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(repoRoot, tool);
+    await releaseLock2(repoRoot, tool);
   }
 }
 async function handleStop(payload, tool) {
-  const cwd = resolveCwd(payload);
+  const cwd = resolveCwd2(payload);
   if (!cwd) return;
   const project = await findProjectForCwd(cwd);
   if (!project) return;
-  const sessionId = resolveSessionId(payload);
+  const sessionId = resolveSessionId2(payload);
   const recordedAt = Date.now();
   const repos = await loadConfiguredRepos();
   const repoByRoot = new Map(repos.map((repo) => [repo.repoRoot, repo]));
@@ -14370,7 +14884,7 @@ async function handleStop(payload, tool) {
   if (sessionId) {
     const storedStates = await listSessionStatesForSession(tool, sessionId);
     for (const { state } of storedStates) {
-      const repo = repoByRoot.get(path15.resolve(state.repoRoot));
+      const repo = repoByRoot.get(path16.resolve(state.repoRoot));
       if (!repo) {
         missingConfig++;
         appendLog(
@@ -14406,7 +14920,7 @@ async function handleStop(payload, tool) {
   );
 }
 async function cleanupSessionStateForRepo(repoRoot, tool, sessionId) {
-  await acquireLock(repoRoot, tool);
+  await acquireLock2(repoRoot, tool);
   try {
     const state = await readSessionState(repoRoot, tool, sessionId);
     if (!state) return "no-state";
@@ -14424,19 +14938,19 @@ async function cleanupSessionStateForRepo(repoRoot, tool, sessionId) {
     );
     return "failed";
   } finally {
-    await releaseLock(repoRoot, tool);
+    await releaseLock2(repoRoot, tool);
   }
 }
 async function handleSessionEnd(payload, tool) {
-  const cwd = resolveCwd(payload);
-  const sessionId = resolveSessionId(payload);
+  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(path15.resolve(state.repoRoot));
+      repoRoots.push(path16.resolve(state.repoRoot));
     }
   }
   if (repoRoots.length === 0 && cwd) {
@@ -14463,7 +14977,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",
@@ -14472,7 +14986,7 @@ var KNOWN_TOOLS = /* @__PURE__ */ new Set([
   "cursor",
   "opencode"
 ]);
-function classifyHookEvent(event) {
+function classifyHookEvent2(event) {
   switch (event) {
     case "SessionStart":
     case "sessionStart":
@@ -14507,7 +15021,7 @@ 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) {
@@ -14522,7 +15036,7 @@ async function repairHookForTool(repoRoot, tool) {
 }
 async function selfHealHook2(payload, tool) {
   if (process.env.HILLCLIMB_SKIP_HOOK_SELF_HEAL === "1") return;
-  const cwd = resolveCwd2(payload);
+  const cwd = resolveCwd3(payload);
   if (!cwd) return;
   try {
     const project = await findProjectForCwd(cwd);
@@ -14546,7 +15060,7 @@ async function resolveLegacyBareTool(raw) {
     );
     return null;
   }
-  const cwd = resolveCwd2(payload);
+  const cwd = resolveCwd3(payload);
   if (!cwd) {
     appendLog(
       "error",
@@ -14705,6 +15219,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(
@@ -14713,9 +15228,9 @@ async function runGitTracesWorker() {
     );
     return;
   }
-  await selfHealHook2(payload, tool);
   try {
-    switch (classifyHookEvent(event)) {
+    await selfHealHook2(payload, tool);
+    switch (eventKind) {
       case "sessionStart":
         await handleSessionStart(payload, tool);
         break;
@@ -14736,19 +15251,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 path17 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 path16 from "path";
+import path17 from "path";
 function getDownloadsFolder() {
   const home = os8.homedir();
   if (process.platform === "linux") {
@@ -14757,12 +15280,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 = path16.join(home, "Downloads");
-  if (fs12.existsSync(downloads)) return downloads;
+  const downloads = path17.join(home, "Downloads");
+  if (fs13.existsSync(downloads)) return downloads;
   return home;
 }
 
@@ -14771,11 +15294,11 @@ function sanitizeFilename(name) {
   return name.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function getUniqueFilename(dir, base, ext) {
-  let candidate = path17.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 = path17.join(dir, `${base}-${i}${ext}`);
+  while (fs14.existsSync(candidate)) {
+    candidate = path18.join(dir, `${base}-${i}${ext}`);
     i++;
   }
   return candidate;
@@ -14785,13 +15308,13 @@ var ZipOutput = class {
   label = "Save as .zip to Downloads";
   async emit(group, options) {
     const downloadsDir = getDownloadsFolder();
-    const repoName = sanitizeFilename(path17.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);
@@ -14985,15 +15508,15 @@ async function confirmExport(group, output) {
 }
 
 // src/sources/claude.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import os9 from "os";
-import path18 from "path";
+import path19 from "path";
 import readline from "readline";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["tool-results"]);
 async function resolveRepoPath(projectDir) {
-  const indexPath = path18.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;
@@ -15001,12 +15524,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(path18.join(projectDir, entry.name));
+    const cwd = await extractCwdFromJsonl(path19.join(projectDir, entry.name));
     if (cwd) {
       cwdCounts.set(cwd, (cwdCounts.get(cwd) ?? 0) + 1);
     }
@@ -15025,7 +15548,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) {
@@ -15047,12 +15570,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 = path18.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);
@@ -15074,19 +15597,19 @@ function fallbackDecode(encodedName) {
 var ClaudeSource = class {
   name = "claude";
   async scan() {
-    const baseDir = path18.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 = path18.join(baseDir, dir.name);
+        const projectPath = path19.join(baseDir, dir.name);
         const repoPath = await resolveRepoPath(projectPath) ?? fallbackDecode(dir.name);
         const files = [];
         await collectFiles(
@@ -15104,12 +15627,12 @@ var ClaudeSource = class {
 };
 
 // src/sources/codex.ts
-import fs15 from "fs";
+import fs16 from "fs";
 import os10 from "os";
-import path19 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) {
@@ -15134,12 +15657,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 = path19.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")) {
@@ -15153,11 +15676,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) {
@@ -15184,14 +15707,14 @@ async function loadHistory(historyPath) {
 var CodexSource = class {
   name = "codex";
   async scan() {
-    const codexDir = path19.join(os10.homedir(), ".codex");
-    const sessionsDir = path19.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 = path19.join(codexDir, "history.jsonl");
+    const historyPath = path20.join(codexDir, "history.jsonl");
     const [jsonlFiles, historyMap] = await Promise.all([
       findJsonlFiles(sessionsDir),
       loadHistory(historyPath)
@@ -15214,8 +15737,8 @@ var CodexSource = class {
       });
       const historyLines = historyMap.get(meta.sessionId);
       if (historyLines) {
-        const sessionDir = path19.relative(sessionsDir, path19.dirname(filePath));
-        const historyAbsPath = path19.join(
+        const sessionDir = path20.relative(sessionsDir, path20.dirname(filePath));
+        const historyAbsPath = path20.join(
           sessionsDir,
           sessionDir,
           `history-${meta.sessionId}.jsonl`
@@ -15235,18 +15758,18 @@ var CodexSource = class {
 };
 
 // src/sources/copilotChat.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import os11 from "os";
-import path20 from "path";
+import path21 from "path";
 import { fileURLToPath } from "url";
 function vsCodeUserDirs() {
   const home = os11.homedir();
   const dirs = [
-    path20.join(home, "Library", "Application Support", "Code", "User"),
-    path20.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(path20.join(process.env.APPDATA, "Code", "User"));
+    dirs.push(path21.join(process.env.APPDATA, "Code", "User"));
   }
   return dirs;
 }
@@ -15261,7 +15784,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;
   }
@@ -15283,10 +15806,10 @@ var CopilotChatSource = class {
   async scan() {
     const results = [];
     for (const userDir of vsCodeUserDirs()) {
-      const workspaceStorage = path20.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 {
@@ -15294,22 +15817,22 @@ var CopilotChatSource = class {
       }
       for (const hash of hashDirs) {
         if (!hash.isDirectory()) continue;
-        const wsRoot = path20.join(workspaceStorage, hash.name);
-        const transcriptsDir = path20.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(
-          path20.join(wsRoot, "workspace.json")
+          path21.join(wsRoot, "workspace.json")
         );
         if (!repoPath) continue;
         for (const entry of transcriptEntries) {
@@ -15317,7 +15840,7 @@ var CopilotChatSource = class {
           const sessionId = entry.name.slice(0, -".jsonl".length);
           results.push({
             sourceName: this.name,
-            absolutePath: path20.join(transcriptsDir, entry.name),
+            absolutePath: path21.join(transcriptsDir, entry.name),
             repoPath,
             metadata: { sessionId }
           });
@@ -15357,7 +15880,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 = [];
@@ -15384,10 +15907,10 @@ async function runInteractive() {
   s.start(`Scanning ${source.name} logs...`);
   const allFiles = await source.scan();
   const allGroups = await mergeByRepo(allFiles);
-  const repoRoot = path21.resolve(repo.root);
+  const repoRoot = path22.resolve(repo.root);
   const matching = allGroups.filter((g) => {
-    const resolved = path21.resolve(g.repoPath);
-    return resolved === repoRoot || resolved.startsWith(repoRoot + path21.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}.`);
@@ -15418,7 +15941,7 @@ async function runInteractive() {
     }
   }
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path21.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path22.join(repoRoot, n));
   const additionalFiles = await promptSecretFiles(envFileNames);
   const secretResult = await collectSecrets(
     repoRoot,