hillclimb 0.1.9 → 0.3.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import fs17 from "fs";
-import path20 from "path";
+import path21 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 = 3;
+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
@@ -864,20 +868,54 @@ import path from "node:path";
 const TOOL = "opencode";
 const TRANSCRIPT_DIR = path.join(os.homedir(), ".hillclimb", "opencode-transcripts");
 
-// sessionID -> Map<messageID, messageInfo>. Using a Map-of-Maps so late
-// message.updated events (streaming deltas) overwrite earlier versions of
-// the same message instead of appending duplicates.
+// sessionID -> Map<messageID, { info, parts }>. Using a Map-of-Maps so late
+// message.updated / message.part.updated events overwrite earlier versions
+// instead of appending duplicates.
 const sessionMessages = new Map();
 
-function ingestMessage(sessionID, info) {
-  if (!sessionID || !info) return;
+function ensureRecord(sessionID, messageID, info) {
+  if (!sessionID || !messageID) return null;
   let bucket = sessionMessages.get(sessionID);
   if (!bucket) {
     bucket = new Map();
     sessionMessages.set(sessionID, bucket);
   }
-  const id = info.id || ((info.role || "unknown") + "-" + bucket.size);
-  bucket.set(id, info);
+  let record = bucket.get(messageID);
+  if (!record) {
+    record = {
+      info: info || { id: messageID, sessionID },
+      parts: new Map(),
+    };
+    bucket.set(messageID, record);
+  } else if (info) {
+    record.info = Object.assign({}, record.info || {}, info);
+  }
+  return record;
+}
+
+function ingestMessage(sessionID, info) {
+  if (!sessionID || !info) return;
+  const id = info.id || ((info.role || "unknown") + "-" + Date.now());
+  ensureRecord(sessionID, id, info);
+}
+
+function ingestPart(sessionID, part) {
+  if (!part) return;
+  const sid = sessionID || part.sessionID;
+  const messageID = part.messageID;
+  if (!sid || !messageID) return;
+  const record = ensureRecord(sid, messageID, { id: messageID, sessionID: sid });
+  if (!record) return;
+  const partID = part.id || ((part.type || "part") + "-" + record.parts.size);
+  record.parts.set(partID, part);
+}
+
+function serializeRecord(record) {
+  const info = record.info || {};
+  const parts = Array.from(record.parts.values());
+  if (parts.length === 0) return info;
+  // Preserve the old top-level message-info shape while adding parts.
+  return Object.assign({}, info, { parts });
 }
 
 function writeTranscript(sessionID) {
@@ -887,7 +925,7 @@ function writeTranscript(sessionID) {
     fs.mkdirSync(TRANSCRIPT_DIR, { recursive: true });
     const file = path.join(TRANSCRIPT_DIR, sessionID + ".jsonl");
     const lines = [];
-    for (const msg of bucket.values()) lines.push(JSON.stringify(msg));
+    for (const record of bucket.values()) lines.push(JSON.stringify(serializeRecord(record)));
     fs.writeFileSync(file, lines.join("\\n") + "\\n");
     return file;
   } catch {
@@ -917,17 +955,27 @@ export const HillclimbPlugin = async ({ directory }) => ({
   event: async ({ event }) => {
     const type = event && event.type;
     const props = (event && event.properties) || {};
-    const sessionID = props.sessionID;
+    const info = props.info || {};
+    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") {
-      ingestMessage(sessionID, props.info);
+      ingestMessage(sessionID, info);
+      return;
+    }
+
+    if (type === "message.part.updated") {
+      ingestPart(sessionID, props.part);
       return;
     }
 
     if (type === "session.created" && sessionID) {
       spawnHillclimb("git-traces --tool=opencode", {
         session_id: sessionID,
-        cwd: directory,
+        cwd,
         hook_event_name: "session.created",
         tool: TOOL,
       });
@@ -940,7 +988,7 @@ export const HillclimbPlugin = async ({ directory }) => ({
       // so a single session produces one contribution, not one per turn.
       spawnHillclimb("git-traces --tool=opencode", {
         session_id: sessionID,
-        cwd: directory,
+        cwd,
         hook_event_name: "session.idle",
         tool: TOOL,
       });
@@ -949,45 +997,53 @@ 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", {
           session_id: sessionID,
-          cwd: directory,
+          cwd,
           transcript_path: transcriptPath,
           hook_event_name: "session.deleted",
           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) {
           spawnHillclimb("upload", {
             session_id: sid,
-            cwd: directory,
+            cwd,
             transcript_path: transcriptPath,
             hook_event_name: "server.instance.disposed",
             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: directory,
+        cwd,
         hook_event_name: "server.instance.disposed",
         tool: TOOL,
       });
@@ -998,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) {
@@ -1038,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) {
@@ -1066,21 +1132,38 @@ 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") {
     const r = await opencodeInstall(file);
-    return { settingsFile: file, ...r };
+    return { settingsFile: file, ...r, changed: r.installed > 0 };
   }
   const settings = await readJson(file);
   let installed = 0;
   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
@@ -1093,7 +1176,7 @@ async function installHooksForTool(repoRoot, def) {
     }
   }
   if (mutated) await writeJson(file, settings);
-  return { settingsFile: file, installed, alreadyPresent };
+  return { settingsFile: file, installed, alreadyPresent, changed: mutated };
 }
 async function checkHooksForTool(repoRoot, def) {
   const file = settingsPath(repoRoot, def);
@@ -1116,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));
 }
@@ -1133,6 +1237,29 @@ async function installDetectedHooks(repoRoot) {
   }
   return results;
 }
+async function healHookForTool(repoRoot, tool) {
+  const def = TOOLS.find((candidate) => candidate.tool === tool);
+  if (!def) {
+    return {
+      tool,
+      changed: false,
+      alreadyCurrent: false,
+      installed: 0,
+      alreadyPresent: 0,
+      skipped: "unsupported-tool"
+    };
+  }
+  const r = await installHooksForTool(repoRoot, def);
+  return {
+    tool: def.tool,
+    label: def.label,
+    settingsFile: r.settingsFile,
+    changed: r.changed,
+    alreadyCurrent: !r.changed,
+    installed: r.installed,
+    alreadyPresent: r.alreadyPresent
+  };
+}
 async function checkAllHooks(repoRoot) {
   const results = [];
   for (const def of TOOLS) {
@@ -11240,6 +11367,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")) {
@@ -11253,7 +11433,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"]) {
@@ -11370,6 +11550,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;
     }
@@ -11425,7 +11612,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) {
@@ -11460,7 +11648,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] };
     }
@@ -11488,6 +11677,288 @@ function convertEventToStep2(event, stepId, defaultModelName) {
   return null;
 }
 
+// src/normalizer/types.ts
+var ATIF_VERSION = "ATIF-v1.6";
+function excludeNone(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      result[key] = value.map(
+        (item) => typeof item === "object" && item !== null && !Array.isArray(item) ? excludeNone(item) : item
+      );
+    } else if (typeof value === "object" && !Array.isArray(value)) {
+      result[key] = excludeNone(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/normalizer/copilotChat.ts
+function asObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function compactExtra2(extra) {
+  const result = {};
+  for (const [key, value] of Object.entries(extra)) {
+    if (value !== void 0 && value !== null) result[key] = value;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseJsonLines(content) {
+  const entries = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = asObject2(JSON.parse(trimmed));
+      if (!parsed) continue;
+      entries.push({
+        type: typeof parsed.type === "string" ? parsed.type : void 0,
+        data: asObject2(parsed.data),
+        id: typeof parsed.id === "string" ? parsed.id : void 0,
+        timestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : void 0
+      });
+    } catch {
+    }
+  }
+  return entries;
+}
+function parseArguments(value) {
+  const obj = asObject2(value);
+  if (obj) return obj;
+  if (typeof value === "string") {
+    try {
+      const parsed = asObject2(JSON.parse(value));
+      if (parsed) return parsed;
+    } catch {
+      return value ? { input: value } : {};
+    }
+  }
+  return value === void 0 || value === null ? {} : { value };
+}
+function buildMetrics2(data) {
+  const inputTokens = asNumber(data.inputTokens) ?? 0;
+  const outputTokens = asNumber(data.outputTokens) ?? 0;
+  const cacheReadTokens = asNumber(data.cacheReadTokens) ?? 0;
+  const cacheWriteTokens = asNumber(data.cacheWriteTokens) ?? 0;
+  const cost = asNumber(data.cost);
+  if (!inputTokens && !outputTokens && !cacheReadTokens && !cacheWriteTokens && !cost) {
+    return void 0;
+  }
+  return {
+    prompt_tokens: inputTokens + cacheReadTokens || void 0,
+    completion_tokens: outputTokens || void 0,
+    cached_tokens: cacheReadTokens || void 0,
+    cost_usd: cost || void 0,
+    extra: compactExtra2({
+      cache_write_tokens: cacheWriteTokens || void 0,
+      duration_ms: data.duration,
+      initiator: data.initiator,
+      api_call_id: data.apiCallId,
+      provider_call_id: data.providerCallId,
+      parent_tool_call_id: data.parentToolCallId,
+      quota_snapshots: data.quotaSnapshots,
+      copilot_usage: data.copilotUsage
+    })
+  };
+}
+function finalMetricsFromSteps(steps) {
+  let prompt = 0;
+  let completion = 0;
+  let cached = 0;
+  let cost = 0;
+  for (const step of steps) {
+    prompt += step.metrics?.prompt_tokens ?? 0;
+    completion += step.metrics?.completion_tokens ?? 0;
+    cached += step.metrics?.cached_tokens ?? 0;
+    cost += step.metrics?.cost_usd ?? 0;
+  }
+  return {
+    total_prompt_tokens: prompt || void 0,
+    total_completion_tokens: completion || void 0,
+    total_cached_tokens: cached || void 0,
+    total_cost_usd: cost || void 0,
+    total_steps: steps.length
+  };
+}
+function makeToolCall(request) {
+  const req = asObject2(request);
+  if (!req) return null;
+  const callId = typeof req.toolCallId === "string" && req.toolCallId || typeof req.id === "string" && req.id || "";
+  const name = typeof req.name === "string" && req.name || typeof req.toolName === "string" && req.toolName || "tool";
+  return {
+    tool_call_id: callId,
+    function_name: name,
+    arguments: parseArguments(req.arguments)
+  };
+}
+function toolCallFromExecutionStart(data) {
+  const callId = typeof data.toolCallId === "string" && data.toolCallId || typeof data.id === "string" && data.id || "";
+  const name = typeof data.toolName === "string" && data.toolName || typeof data.name === "string" && data.name || "tool";
+  return {
+    tool_call_id: callId,
+    function_name: name,
+    arguments: parseArguments(data.arguments)
+  };
+}
+function contentFromToolResult(data) {
+  const result = asObject2(data.result);
+  if (typeof result?.content === "string") return result.content;
+  if (typeof data.content === "string") return data.content;
+  return void 0;
+}
+function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
+  const entries = parseJsonLines(jsonlContent);
+  if (entries.length === 0) return null;
+  let sid = sessionId ?? "unknown";
+  let copilotVersion = "unknown";
+  let vscodeVersion;
+  let cwd;
+  let defaultModelName;
+  const steps = [];
+  const pendingReasoning = [];
+  const pendingToolSteps = /* @__PURE__ */ new Map();
+  let lastAgentStep;
+  for (const entry of entries) {
+    const data = entry.data ?? {};
+    if (entry.type === "session.start") {
+      if (!sessionId && typeof data.sessionId === "string")
+        sid = data.sessionId;
+      if (typeof data.copilotVersion === "string")
+        copilotVersion = data.copilotVersion;
+      if (typeof data.vscodeVersion === "string")
+        vscodeVersion = data.vscodeVersion;
+      const context = asObject2(data.context);
+      if (typeof context?.cwd === "string") cwd = context.cwd;
+      continue;
+    }
+    if (entry.type === "user.message" || entry.type === "system.message") {
+      const content = typeof data.content === "string" && data.content || typeof data.transformedContent === "string" && data.transformedContent || "";
+      if (!content.trim()) continue;
+      const source = entry.type === "system.message" ? "system" : "user";
+      const step = {
+        step_id: steps.length + 1,
+        timestamp: entry.timestamp,
+        source,
+        message: content,
+        extra: compactExtra2({
+          attachments: data.attachments,
+          source: data.source,
+          agent_mode: data.agentMode,
+          interaction_id: data.interactionId
+        })
+      };
+      steps.push(step);
+      continue;
+    }
+    if (entry.type === "assistant.reasoning") {
+      if (typeof data.content === "string" && data.content.trim()) {
+        pendingReasoning.push(data.content.trim());
+      }
+      continue;
+    }
+    if (entry.type === "assistant.message") {
+      const toolCalls = (Array.isArray(data.toolRequests) ? data.toolRequests : []).flatMap((request) => {
+        const call = makeToolCall(request);
+        return call ? [call] : [];
+      });
+      const content = typeof data.content === "string" && data.content.trim() ? data.content.trim() : "";
+      const reasoning = typeof data.reasoningText === "string" && data.reasoningText.trim() || pendingReasoning.join("\n\n") || void 0;
+      pendingReasoning.length = 0;
+      const step = {
+        step_id: steps.length + 1,
+        timestamp: entry.timestamp,
+        source: "agent",
+        message: content || (toolCalls.length > 0 ? "(tool use)" : ""),
+        model_name: defaultModelName,
+        extra: compactExtra2({
+          message_id: data.messageId,
+          phase: data.phase,
+          output_tokens: data.outputTokens
+        })
+      };
+      if (reasoning) step.reasoning_content = reasoning;
+      if (toolCalls.length > 0) step.tool_calls = toolCalls;
+      if (step.message || step.tool_calls?.length || step.reasoning_content) {
+        steps.push(step);
+        lastAgentStep = step;
+        for (const call of toolCalls) {
+          if (call.tool_call_id) pendingToolSteps.set(call.tool_call_id, step);
+        }
+      }
+      continue;
+    }
+    if (entry.type === "tool.execution_start") {
+      const toolCall = toolCallFromExecutionStart(data);
+      const step = {
+        step_id: steps.length + 1,
+        timestamp: entry.timestamp,
+        source: "agent",
+        message: `Executed ${toolCall.function_name} ${toolCall.tool_call_id}`.trim(),
+        model_name: defaultModelName,
+        tool_calls: [toolCall]
+      };
+      steps.push(step);
+      lastAgentStep = step;
+      if (toolCall.tool_call_id)
+        pendingToolSteps.set(toolCall.tool_call_id, step);
+      continue;
+    }
+    if (entry.type === "tool.execution_complete") {
+      const callId = typeof data.toolCallId === "string" && data.toolCallId || typeof data.id === "string" && data.id || "";
+      const target = pendingToolSteps.get(callId);
+      const content = contentFromToolResult(data);
+      if (target && content !== void 0) {
+        const observation = target.observation ?? { results: [] };
+        observation.results.push({
+          source_call_id: callId || void 0,
+          content
+        });
+        target.observation = observation;
+        const extra = { ...target.extra ?? {} };
+        extra.tool_success = data.success;
+        target.extra = compactExtra2(extra);
+      }
+      if (callId) pendingToolSteps.delete(callId);
+      continue;
+    }
+    if (entry.type === "assistant.usage") {
+      if (typeof data.model === "string" && !defaultModelName) {
+        defaultModelName = data.model;
+        if (lastAgentStep && !lastAgentStep.model_name) {
+          lastAgentStep.model_name = defaultModelName;
+        }
+      }
+      const metrics = buildMetrics2(data);
+      if (metrics && lastAgentStep && !lastAgentStep.metrics) {
+        lastAgentStep.metrics = metrics;
+      }
+    }
+  }
+  if (steps.length === 0) return null;
+  return {
+    schema_version: ATIF_VERSION,
+    session_id: sid,
+    agent: {
+      name: "github-copilot-chat",
+      version: copilotVersion,
+      model_name: defaultModelName,
+      extra: compactExtra2({
+        vscode_version: vscodeVersion,
+        cwd
+      })
+    },
+    steps,
+    final_metrics: finalMetricsFromSteps(steps)
+  };
+}
+
 // src/normalizer/cursor.ts
 function convertCursorToTrajectory(jsonlContent, sessionId) {
   const lines = [];
@@ -11545,80 +12016,566 @@ function convertCursorToTrajectory(jsonlContent, sessionId) {
   };
 }
 
-// src/normalizer/types.ts
-function excludeNone(obj) {
+// src/normalizer/opencode.ts
+function asObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function compactExtra3(extra) {
   const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (value === void 0 || value === null) continue;
-    if (Array.isArray(value)) {
-      result[key] = value.map(
-        (item) => typeof item === "object" && item !== null && !Array.isArray(item) ? excludeNone(item) : item
-      );
-    } else if (typeof value === "object" && !Array.isArray(value)) {
-      result[key] = excludeNone(value);
-    } else {
-      result[key] = value;
+  for (const [key, value] of Object.entries(extra)) {
+    if (value !== void 0 && value !== null) result[key] = value;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseJsonLines2(content) {
+  const events = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      const obj = asObject3(parsed);
+      if (obj) events.push(obj);
+    } catch {
     }
   }
-  return result;
+  return events;
 }
-
-// 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);
-    default:
-      return null;
+function timestampToIso(value) {
+  const numeric = asNumber2(value);
+  if (numeric === void 0) return void 0;
+  const millis = numeric < 1e12 ? numeric * 1e3 : numeric;
+  const date = new Date(millis);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+function timeFromObject(value) {
+  const obj = asObject3(value);
+  if (!obj) return void 0;
+  return timestampToIso(obj.start ?? obj.created ?? obj.completed ?? obj.end);
+}
+function stringify2(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
   }
 }
-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"].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 };
+function argsFromUnknown(value) {
+  const obj = asObject3(value);
+  if (obj) return obj;
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      const parsedObj = asObject3(parsed);
+      if (parsedObj) return parsedObj;
+    } catch {
+      return value ? { input: value } : {};
+    }
+  }
+  return value === void 0 || value === null ? {} : { value };
+}
+function modelNameFromInfo(info) {
+  const model = asObject3(info.model);
+  const modelID = typeof info.modelID === "string" && info.modelID || typeof model?.modelID === "string" && model.modelID || void 0;
+  const providerID = typeof info.providerID === "string" && info.providerID || typeof model?.providerID === "string" && model.providerID || void 0;
+  if (providerID && modelID) return `${providerID}/${modelID}`;
+  return modelID;
+}
+function metricsFromTokens(tokens, cost) {
+  const t = asObject3(tokens);
+  if (!t) return void 0;
+  const cache = asObject3(t.cache);
+  const input = asNumber2(t.input) ?? 0;
+  const output = asNumber2(t.output) ?? 0;
+  const reasoning = asNumber2(t.reasoning) ?? 0;
+  const cacheRead = asNumber2(cache?.read) ?? 0;
+  const cacheWrite = asNumber2(cache?.write) ?? 0;
+  const costUsd = asNumber2(cost);
+  if (!input && !output && !cacheRead && !cacheWrite && !costUsd) {
+    return void 0;
   }
-};
-
-// src/outputs/platform.ts
-import { PassThrough } from "stream";
-import archiver from "archiver";
-
-// src/outputs/archive.ts
+  const extra = compactExtra3({
+    reasoning_tokens: reasoning || void 0,
+    cache_write_tokens: cacheWrite || void 0
+  });
+  return {
+    prompt_tokens: input + cacheRead || void 0,
+    completion_tokens: output || void 0,
+    cached_tokens: cacheRead || void 0,
+    cost_usd: costUsd || void 0,
+    extra
+  };
+}
+function metricsFromInfo(info) {
+  return metricsFromTokens(info.tokens, info.cost);
+}
+function addFinalMetricTotals(totals, metrics) {
+  if (!metrics) return;
+  totals.total_prompt_tokens += metrics.prompt_tokens ?? 0;
+  totals.total_completion_tokens += metrics.completion_tokens ?? 0;
+  totals.total_cached_tokens += metrics.cached_tokens ?? 0;
+  totals.total_cost_usd += metrics.cost_usd ?? 0;
+}
+function finalMetricsFromSteps2(steps) {
+  const totals = {
+    total_prompt_tokens: 0,
+    total_completion_tokens: 0,
+    total_cached_tokens: 0,
+    total_cost_usd: 0,
+    total_steps: steps.length,
+    extra: {}
+  };
+  for (const step of steps) addFinalMetricTotals(totals, step.metrics);
+  return {
+    total_prompt_tokens: totals.total_prompt_tokens || void 0,
+    total_completion_tokens: totals.total_completion_tokens || void 0,
+    total_cached_tokens: totals.total_cached_tokens || void 0,
+    total_cost_usd: totals.total_cost_usd || void 0,
+    total_steps: steps.length
+  };
+}
+function entryFromLine(line) {
+  const info = asObject3(line.info);
+  if (info) {
+    return {
+      info,
+      parts: asArray(line.parts).flatMap((part) => {
+        const obj = asObject3(part);
+        return obj ? [obj] : [];
+      })
+    };
+  }
+  if (typeof line.role === "string" || typeof line.sessionID === "string") {
+    return {
+      info: line,
+      parts: asArray(line.parts).flatMap((part) => {
+        const obj = asObject3(part);
+        return obj ? [obj] : [];
+      })
+    };
+  }
+  return null;
+}
+function entriesFromEventWrappers(lines) {
+  const byMessage = /* @__PURE__ */ new Map();
+  function getEntry(messageID, sessionID) {
+    let entry = byMessage.get(messageID);
+    if (!entry) {
+      entry = { info: { id: messageID, sessionID }, parts: [] };
+      byMessage.set(messageID, entry);
+    }
+    return entry;
+  }
+  for (const line of lines) {
+    const type = line.type;
+    const props = asObject3(line.properties) ?? line;
+    if (type === "message.updated") {
+      const info = asObject3(props.info);
+      const id = typeof info?.id === "string" ? info.id : void 0;
+      if (!info || !id) continue;
+      const entry = getEntry(id, info.sessionID);
+      entry.info = info;
+      continue;
+    }
+    if (type === "message.part.updated") {
+      const part = asObject3(props.part);
+      const messageID = typeof part?.messageID === "string" && part.messageID || void 0;
+      if (!part || !messageID) continue;
+      const entry = getEntry(messageID, part.sessionID);
+      const partID = typeof part.id === "string" ? part.id : void 0;
+      const existingIndex = partID ? entry.parts.findIndex((p7) => p7.id === partID) : -1;
+      if (existingIndex >= 0) entry.parts[existingIndex] = part;
+      else entry.parts.push(part);
+    }
+  }
+  return [...byMessage.values()];
+}
+function getSessionId(sessionId, exportInfo, entries) {
+  if (sessionId) return sessionId;
+  if (typeof exportInfo?.id === "string") return exportInfo.id;
+  for (const entry of entries) {
+    if (typeof entry.info.sessionID === "string") return entry.info.sessionID;
+  }
+  return "unknown";
+}
+function getAgentVersion(exportInfo) {
+  return typeof exportInfo?.version === "string" && exportInfo.version || "unknown";
+}
+function sortEntries(entries) {
+  return [...entries].sort((a, b) => {
+    const at = asNumber2(asObject3(a.info.time)?.created) ?? 0;
+    const bt = asNumber2(asObject3(b.info.time)?.created) ?? 0;
+    return at - bt;
+  });
+}
+function splitAssistantParts(parts) {
+  let sawBoundary = false;
+  const groups = [];
+  let current = [];
+  for (const part of parts) {
+    const type = part.type;
+    if (type === "step-start") {
+      sawBoundary = true;
+      if (current.length > 0) groups.push(current);
+      current = [part];
+      continue;
+    }
+    current.push(part);
+    if (type === "step-finish") {
+      sawBoundary = true;
+      groups.push(current);
+      current = [];
+    }
+  }
+  if (current.length > 0) groups.push(current);
+  return sawBoundary ? groups : [parts];
+}
+function textFromFilePart(part) {
+  const filename = typeof part.filename === "string" ? part.filename : void 0;
+  const url = typeof part.url === "string" ? part.url : void 0;
+  const mime = typeof part.mime === "string" ? part.mime : void 0;
+  const label = filename ?? url;
+  if (!label) return void 0;
+  return mime ? `[file:${mime}] ${label}` : `[file] ${label}`;
+}
+function buildUserStep(entry, stepId, defaultModelName) {
+  const textParts = [];
+  const extra = {};
+  for (const part of entry.parts) {
+    if (part.type === "text" && typeof part.text === "string") {
+      if (part.text.trim()) textParts.push(part.text.trim());
+      continue;
+    }
+    if (part.type === "file") {
+      const fileText = textFromFilePart(part);
+      if (fileText) textParts.push(fileText);
+    }
+  }
+  const message = textParts.join("\n\n").trim();
+  if (!message) return null;
+  if (entry.info.agent) extra.agent = entry.info.agent;
+  if (entry.info.tools) extra.tools = entry.info.tools;
+  return {
+    step_id: stepId,
+    timestamp: timeFromObject(entry.info.time),
+    source: "user",
+    message,
+    model_name: defaultModelName,
+    extra: compactExtra3(extra)
+  };
+}
+function buildAgentStep(parts, info, stepId, defaultModelName, fallbackMetrics) {
+  const textParts = [];
+  const reasoningParts = [];
+  const toolCalls = [];
+  const observationResults = [];
+  const extra = {};
+  let metrics;
+  let timestamp = timeFromObject(info.time);
+  for (const part of parts) {
+    if (!timestamp) timestamp = timeFromObject(part.time);
+    switch (part.type) {
+      case "text":
+        if (typeof part.text === "string" && part.text.trim()) {
+          textParts.push(part.text.trim());
+        }
+        break;
+      case "reasoning":
+        if (typeof part.text === "string" && part.text.trim()) {
+          reasoningParts.push(part.text.trim());
+        }
+        break;
+      case "file": {
+        const fileText = textFromFilePart(part);
+        if (fileText) textParts.push(fileText);
+        break;
+      }
+      case "tool": {
+        const state = asObject3(part.state) ?? {};
+        const callID = typeof part.callID === "string" && part.callID || typeof part.id === "string" && part.id || "";
+        const toolName = typeof part.tool === "string" && part.tool || "tool";
+        const input = argsFromUnknown(state.input);
+        toolCalls.push({
+          tool_call_id: callID,
+          function_name: toolName,
+          arguments: input
+        });
+        const output = state.output ?? state.error;
+        if (output !== void 0 && output !== null) {
+          observationResults.push({
+            source_call_id: callID || void 0,
+            content: stringify2(output)
+          });
+        }
+        if (state.status) extra.status = state.status;
+        if (state.metadata) extra.tool_metadata = state.metadata;
+        if (part.metadata) extra.part_metadata = part.metadata;
+        break;
+      }
+      case "step-finish":
+        metrics = metricsFromTokens(part.tokens, part.cost) ?? metrics;
+        if (part.reason) extra.finish_reason = part.reason;
+        if (part.snapshot) extra.snapshot = part.snapshot;
+        break;
+      case "patch":
+        extra.patches = [...asArray(extra.patches), part];
+        break;
+      case "agent":
+        if (part.name) extra.agent = part.name;
+        break;
+      case "retry":
+        extra.retry = part;
+        break;
+    }
+  }
+  metrics = metrics ?? fallbackMetrics;
+  if (textParts.length === 0 && reasoningParts.length === 0 && toolCalls.length === 0 && !metrics) {
+    return null;
+  }
+  const observation = observationResults.length > 0 ? { results: observationResults } : void 0;
+  const step = {
+    step_id: stepId,
+    timestamp,
+    source: "agent",
+    message: textParts.length > 0 ? textParts.join("\n\n") : "(tool use)",
+    model_name: modelNameFromInfo(info) ?? defaultModelName
+  };
+  if (reasoningParts.length > 0)
+    step.reasoning_content = reasoningParts.join("\n\n");
+  if (toolCalls.length > 0) step.tool_calls = toolCalls;
+  if (observation) step.observation = observation;
+  if (metrics) step.metrics = metrics;
+  const compactedExtra = compactExtra3(extra);
+  if (compactedExtra) step.extra = compactedExtra;
+  return step;
+}
+function buildUnavailableAgentStep(info, stepId, defaultModelName) {
+  const metrics = metricsFromInfo(info);
+  if (!metrics && !modelNameFromInfo(info) && !info.error && !info.finish) {
+    return null;
+  }
+  return {
+    step_id: stepId,
+    timestamp: timeFromObject(info.time),
+    source: "agent",
+    message: "(message unavailable)",
+    model_name: modelNameFromInfo(info) ?? defaultModelName,
+    metrics,
+    extra: compactExtra3({
+      content_unavailable: true,
+      finish_reason: info.finish,
+      error: info.error
+    })
+  };
+}
+function convertMessageEntriesToTrajectory(entries, sessionId, exportInfo) {
+  if (entries.length === 0) return null;
+  const orderedEntries = sortEntries(entries);
+  const defaultModelName = orderedEntries.map((entry) => modelNameFromInfo(entry.info)).find((model) => typeof model === "string");
+  const steps = [];
+  for (const entry of orderedEntries) {
+    const role = entry.info.role;
+    if (role === "user") {
+      const step = buildUserStep(entry, steps.length + 1, defaultModelName);
+      if (step) steps.push(step);
+      continue;
+    }
+    if (role !== "assistant") continue;
+    if (entry.parts.length === 0) {
+      const step = buildUnavailableAgentStep(
+        entry.info,
+        steps.length + 1,
+        defaultModelName
+      );
+      if (step) steps.push(step);
+      continue;
+    }
+    const groups = splitAssistantParts(entry.parts);
+    const hasPartMetrics = groups.some(
+      (group) => group.some((part) => part.type === "step-finish")
+    );
+    const fallbackMetrics = hasPartMetrics ? void 0 : metricsFromInfo(entry.info);
+    for (let i = 0; i < groups.length; i++) {
+      const step = buildAgentStep(
+        groups[i],
+        entry.info,
+        steps.length + 1,
+        defaultModelName,
+        i === 0 ? fallbackMetrics : void 0
+      );
+      if (step) steps.push(step);
+    }
+  }
+  if (steps.length === 0) return null;
+  return {
+    schema_version: ATIF_VERSION,
+    session_id: getSessionId(sessionId, exportInfo, orderedEntries),
+    agent: {
+      name: "opencode",
+      version: getAgentVersion(exportInfo),
+      model_name: defaultModelName
+    },
+    steps,
+    final_metrics: finalMetricsFromSteps2(steps)
+  };
+}
+function convertRunEventsToTrajectory(events, sessionId) {
+  const session = sessionId ?? (events.map((event) => event.sessionID).find((sid) => typeof sid === "string") || "unknown");
+  const turns = [];
+  let current = null;
+  for (const event of events) {
+    const type = event.type;
+    if (type === "step_start") {
+      current = { parts: [], timestamp: event.timestamp };
+      continue;
+    }
+    if (type === "step_finish") {
+      if (current) {
+        current.finish = asObject3(event.part) ?? {};
+        turns.push(current);
+        current = null;
+      }
+      continue;
+    }
+    if (current && (type === "text" || type === "reasoning" || type === "tool_use")) {
+      const part = asObject3(event.part);
+      if (part) current.parts.push(part);
+    }
+  }
+  const steps = [];
+  for (const turn of turns) {
+    const parts = [...turn.parts];
+    if (turn.finish) {
+      parts.push({ ...turn.finish, type: "step-finish" });
+    }
+    const step = buildAgentStep(
+      parts,
+      { time: { created: turn.timestamp } },
+      steps.length + 1,
+      void 0
+    );
+    if (step) steps.push(step);
+  }
+  if (steps.length === 0) return null;
+  return {
+    schema_version: ATIF_VERSION,
+    session_id: session,
+    agent: {
+      name: "opencode",
+      version: "unknown"
+    },
+    steps,
+    final_metrics: finalMetricsFromSteps2(steps)
+  };
+}
+function isRunEvent(lines) {
+  return lines.some(
+    (line) => ["step_start", "step_finish", "text", "reasoning", "tool_use"].includes(
+      String(line.type ?? "")
+    )
+  );
+}
+function convertOpenCodeToTrajectory(content, sessionId) {
+  const trimmed = content.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    const parsedObj = asObject3(parsed);
+    const messages = asArray(parsedObj?.messages);
+    if (parsedObj && messages.length > 0) {
+      const entries2 = messages.flatMap((message) => {
+        const entry = entryFromLine(asObject3(message) ?? {});
+        return entry ? [entry] : [];
+      });
+      return convertMessageEntriesToTrajectory(
+        entries2,
+        sessionId,
+        asObject3(parsedObj.info)
+      );
+    }
+  } 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) {
@@ -11843,6 +12800,24 @@ function resolveSourceTool(payload) {
   if (payload.hook_event_name === "Stop") return "codex";
   return "claude";
 }
+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) {
+      appendLog("warn", `self-heal: skipped ${tool} hook (${result.skipped})`);
+      return;
+    }
+    if (result.changed) {
+      appendLog("info", `self-heal: updated ${tool} hook`);
+    }
+  } catch (err) {
+    appendLog(
+      "warn",
+      `self-heal: failed to repair ${tool} hook: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 function resolveCursorTranscriptPath(payload) {
   const id = payload.conversation_id ?? payload.session_id;
   const workspace = payload.workspace_roots?.[0];
@@ -11874,6 +12849,16 @@ async function runUploadInner(payload) {
     );
     return;
   }
+  const match = await findProjectForCwd(cwd);
+  if (!match) {
+    appendLog(
+      "warn",
+      `Skipping session ${sessionId}: no hillclimb config for cwd ${cwd}. Run \`npx hillclimb\` in the repo.`
+    );
+    return;
+  }
+  const { repoRoot, config } = match;
+  await selfHealHook(repoRoot, sourceTool);
   const transcriptResolved = path12.resolve(transcriptPath);
   try {
     const stat = await fs9.promises.stat(transcriptResolved);
@@ -11891,14 +12876,6 @@ async function runUploadInner(payload) {
     );
     return;
   }
-  const match = await findProjectForCwd(cwd);
-  if (!match) {
-    appendLog(
-      "warn",
-      `Skipping session ${sessionId}: no hillclimb config for cwd ${cwd}. Run \`npx hillclimb\` in the repo.`
-    );
-    return;
-  }
   if (!await hasAssistantMessage(transcriptResolved)) {
     appendLog(
       "info",
@@ -11906,7 +12883,6 @@ async function runUploadInner(payload) {
     );
     return;
   }
-  const { repoRoot, config } = match;
   await uploadSession({
     sessionId,
     transcriptPath: transcriptResolved,
@@ -12108,6 +13084,7 @@ import crypto2 from "crypto";
 
 // src/git-traces/handlers.ts
 import { execFileSync as execFileSync2 } from "child_process";
+import path15 from "path";
 
 // src/git-traces/git-ops.ts
 import { execFileSync } from "child_process";
@@ -12362,12 +13339,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;
@@ -12478,9 +13477,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 path22 = parts[parts.length - 1];
+      indexByPath.set(path22, files.length);
+      files.push({ path: path22, status, additions: 0, deletions: 0 });
     }
   }
   for (const line of numstat.split("\n")) {
@@ -12511,6 +13510,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}`,
@@ -12538,20 +13550,24 @@ import fs11 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`);
+var DEFAULT_STATE_DIR = path14.join(os7.homedir(), ".hillclimb", "git-traces");
+var LOCK_RETRIES = 120;
+var LOCK_RETRY_DELAY_MS = 500;
+function stateDir() {
+  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}`
+  ).digest("hex").slice(0, 16);
+  return path14.join(stateDir(), `${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 fs11.promises.readFile(file, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.schemaVersion !== CURRENT_SCHEMA_VERSION) {
       return null;
@@ -12561,42 +13577,130 @@ async function readSessionState(repoRoot, tool) {
     return null;
   }
 }
-async function writeSessionState(state, tool) {
-  const file = stateFileForRepo(state.repoRoot, tool);
-  await fs11.promises.mkdir(STATE_DIR, { recursive: true, mode: 448 });
-  const tmp = `${file}.tmp`;
-  await fs11.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
-    mode: 384
-  });
-  await fs11.promises.rename(tmp, file);
-}
-async function deleteSessionState(repoRoot, tool) {
+async function listScopedSessionStates(repoRoot, tool) {
+  let entries;
   try {
-    await fs11.promises.unlink(stateFileForRepo(repoRoot, tool));
+    entries = await fs11.promises.readdir(stateDir(), { withFileTypes: true });
   } catch {
+    return [];
   }
-}
-async function acquireLock(repoRoot, tool, retries = 3, delayMs = 200) {
-  const lockPath = lockFileForRepo(repoRoot, tool);
-  await fs11.promises.mkdir(STATE_DIR, { recursive: true, mode: 448 });
-  for (let i = 0; i < retries; i++) {
-    try {
-      const fd = await fs11.promises.open(
-        lockPath,
-        fs11.constants.O_CREAT | fs11.constants.O_EXCL | fs11.constants.O_WRONLY
-      );
-      await fd.write(String(process.pid));
-      await fd.close();
-      return fd.fd;
-    } catch (err) {
-      if (err.code === "EEXIST" && i < retries - 1) {
-        await new Promise((r) => setTimeout(r, delayMs));
-        continue;
-      }
-      throw err;
+  const states = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const file = path14.join(stateDir(), entry.name);
+    const state = await readStateFile(file);
+    if (!state) continue;
+    if (typeof state.repoRoot !== "string" || typeof state.sessionId !== "string") {
+      continue;
     }
-  }
-  throw new Error(`Failed to acquire lock after ${retries} retries`);
+    if (path14.resolve(state.repoRoot) !== path14.resolve(repoRoot)) continue;
+    if (path14.resolve(file) !== path14.resolve(stateFileForRepo(repoRoot, tool, state.sessionId))) {
+      continue;
+    }
+    let mtimeMs = 0;
+    try {
+      mtimeMs = (await fs11.promises.stat(file)).mtimeMs;
+    } catch {
+      continue;
+    }
+    states.push({ state, mtimeMs });
+  }
+  return states;
+}
+async function listSessionStatesForSession(tool, sessionId) {
+  let entries;
+  try {
+    entries = await fs11.promises.readdir(stateDir(), { 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 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))) {
+      continue;
+    }
+    let mtimeMs = 0;
+    try {
+      mtimeMs = (await fs11.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, state.sessionId);
+  await fs11.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+  const tmp = `${file}.tmp`;
+  await fs11.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+    mode: 384
+  });
+  await fs11.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 deleteStateFile(file) {
+  try {
+    await fs11.promises.unlink(file);
+  } catch {
+  }
+}
+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 acquireLock(repoRoot, tool, retries = LOCK_RETRIES, delayMs = LOCK_RETRY_DELAY_MS) {
+  const lockPath = lockFileForRepo(repoRoot, tool);
+  await fs11.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
+  for (let i = 0; i < retries; i++) {
+    try {
+      const fd = await fs11.promises.open(
+        lockPath,
+        fs11.constants.O_CREAT | fs11.constants.O_EXCL | fs11.constants.O_WRONLY
+      );
+      await fd.write(String(process.pid));
+      await fd.close();
+      return fd.fd;
+    } catch (err) {
+      if (err.code === "EEXIST" && i < retries - 1) {
+        await new Promise((r) => setTimeout(r, delayMs));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`Failed to acquire lock after ${retries} retries`);
 }
 async function releaseLock(repoRoot, tool) {
   try {
@@ -12606,9 +13710,10 @@ async function releaseLock(repoRoot, tool) {
 }
 
 // src/git-traces/handlers.ts
-var CLI_VERSION = "0.1.0";
+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) {
   return String(Math.floor(date.getTime() / 1e3));
 }
@@ -12619,6 +13724,16 @@ var TOOL_LABELS = {
   "copilot-chat": "GitHub Copilot Chat",
   opencode: "opencode"
 };
+async function loadConfiguredRepos() {
+  const file = await loadProjects();
+  return Object.entries(file.projects).map(([repoRoot, config]) => ({
+    repoRoot: path15.resolve(repoRoot),
+    config
+  })).sort((a, b) => a.repoRoot.localeCompare(b.repoRoot));
+}
+function repoLabel(repoRoot) {
+  return path15.basename(repoRoot) || repoRoot;
+}
 function resolveCwd(payload) {
   return payload.cwd ?? payload.workspace_roots?.[0] ?? null;
 }
@@ -12678,27 +13793,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,
@@ -12710,13 +13841,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(
@@ -12726,6 +13873,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);
@@ -12746,6 +13933,34 @@ async function uploadEpochBaselineArtifacts(params) {
     artifacts.metadataBuffer
   );
 }
+async function createGitTracesContribution(params) {
+  const { client, config, repoRoot, state, tool, now, artifacts } = params;
+  const toolLabel = TOOL_LABELS[tool] ?? "Claude";
+  const epochSeconds = formatEpochSeconds2(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}`,
+    body: `Session ID: ${state.sessionId}
+Tool: ${toolLabel}
+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;
@@ -12769,45 +13984,115 @@ 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,
     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 acquireLock(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 releaseLock(repoRoot, tool);
+  }
+}
 async function handleSessionStart(payload, tool) {
   const cwd = resolveCwd(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);
@@ -12815,115 +14100,146 @@ async function handleSessionStart(payload, tool) {
     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 acquireLock(repoRoot, tool);
+  try {
+    const 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,
@@ -12931,7 +14247,7 @@ Uploaded: ${now.toISOString()}`
         transitionKind,
         startedAt: state.startedAt
       });
-      if (!artifacts) return;
+      if (!artifacts) return "failed";
       const next = {
         ...state,
         baselineSha: artifacts.baselineSha,
@@ -12943,66 +14259,204 @@ 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)}`
+    );
+    return "failed";
   } finally {
-    await releaseLock(cwd, tool);
+    await releaseLock(repoRoot, tool);
   }
 }
-async function handleSessionEnd(payload, tool) {
+async function handleStop(payload, tool) {
   const cwd = resolveCwd(payload);
   if (!cwd) return;
-  await acquireLock(cwd, tool);
+  const project = await findProjectForCwd(cwd);
+  if (!project) return;
+  const sessionId = resolveSessionId(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(path15.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 acquireLock(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 releaseLock(repoRoot, tool);
   }
 }
+async function handleSessionEnd(payload, tool) {
+  const cwd = resolveCwd(payload);
+  const sessionId = resolveSessionId(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));
+    }
+  }
+  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
 var WORKER_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_WORKER";
@@ -13018,6 +14472,25 @@ var KNOWN_TOOLS = /* @__PURE__ */ new Set([
   "cursor",
   "opencode"
 ]);
+function classifyHookEvent(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];
@@ -13034,6 +14507,96 @@ async function readStdin2() {
   }
   return Buffer.concat(chunks).toString("utf-8");
 }
+function resolveCwd2(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) {
+  if (process.env.HILLCLIMB_SKIP_HOOK_SELF_HEAL === "1") return;
+  const cwd = resolveCwd2(payload);
+  if (!cwd) return;
+  try {
+    const project = await findProjectForCwd(cwd);
+    if (!project) 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 = resolveCwd2(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;
+    }
+    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",
+      `git-traces: failed legacy hook repair: ${formatError(err)}`
+    );
+    return null;
+  }
+}
 async function runGitTraces() {
   if (process.env[WORKER_ENV_FLAG2] === "1") {
     await runGitTracesWorker();
@@ -13046,13 +14609,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();
@@ -13064,6 +14620,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");
@@ -13072,14 +14637,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
         }
       }
@@ -13148,26 +14713,16 @@ async function runGitTracesWorker() {
     );
     return;
   }
+  await selfHealHook2(payload, tool);
   try {
-    switch (event) {
-      case "SessionStart":
+    switch (classifyHookEvent(event)) {
       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:
@@ -13186,14 +14741,14 @@ ${stack}` : ""}`
 
 // src/outputs/zip.ts
 import fs13 from "fs";
-import path16 from "path";
+import path17 from "path";
 import archiver2 from "archiver";
 
 // src/outputs/downloads.ts
 import { execSync as execSync2 } from "child_process";
 import fs12 from "fs";
 import os8 from "os";
-import path15 from "path";
+import path16 from "path";
 function getDownloadsFolder() {
   const home = os8.homedir();
   if (process.platform === "linux") {
@@ -13206,7 +14761,7 @@ function getDownloadsFolder() {
     } catch {
     }
   }
-  const downloads = path15.join(home, "Downloads");
+  const downloads = path16.join(home, "Downloads");
   if (fs12.existsSync(downloads)) return downloads;
   return home;
 }
@@ -13216,11 +14771,11 @@ function sanitizeFilename(name) {
   return name.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function getUniqueFilename(dir, base, ext) {
-  let candidate = path16.join(dir, `${base}${ext}`);
+  let candidate = path17.join(dir, `${base}${ext}`);
   if (!fs13.existsSync(candidate)) return candidate;
   let i = 1;
   while (fs13.existsSync(candidate)) {
-    candidate = path16.join(dir, `${base}-${i}${ext}`);
+    candidate = path17.join(dir, `${base}-${i}${ext}`);
     i++;
   }
   return candidate;
@@ -13230,7 +14785,7 @@ 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(path17.basename(group.repoPath));
     const timeRange = options.timeRange;
     const rangePart = timeRange?.label ?? "all";
     const epochSeconds = Math.floor(Date.now() / 1e3);
@@ -13432,11 +14987,11 @@ async function confirmExport(group, output) {
 // src/sources/claude.ts
 import fs14 from "fs";
 import os9 from "os";
-import path17 from "path";
+import path18 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 = path18.join(projectDir, "sessions-index.json");
   try {
     const raw = await fs14.promises.readFile(indexPath, "utf-8");
     const data = JSON.parse(raw);
@@ -13451,7 +15006,7 @@ async function resolveRepoPath(projectDir) {
   });
   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(path18.join(projectDir, entry.name));
     if (cwd) {
       cwdCounts.set(cwd, (cwdCounts.get(cwd) ?? 0) + 1);
     }
@@ -13497,7 +15052,7 @@ async function collectFiles(dir, baseDir, sourceName, repoPath, results) {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path17.join(dir, entry.name);
+    const fullPath = path18.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
       await collectFiles(fullPath, baseDir, sourceName, repoPath, results);
@@ -13519,7 +15074,7 @@ function fallbackDecode(encodedName) {
 var ClaudeSource = class {
   name = "claude";
   async scan() {
-    const baseDir = path17.join(os9.homedir(), ".claude", "projects");
+    const baseDir = path18.join(os9.homedir(), ".claude", "projects");
     try {
       await fs14.promises.access(baseDir);
     } catch {
@@ -13531,7 +15086,7 @@ var ClaudeSource = class {
     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 = path18.join(baseDir, dir.name);
         const repoPath = await resolveRepoPath(projectPath) ?? fallbackDecode(dir.name);
         const files = [];
         await collectFiles(
@@ -13551,7 +15106,7 @@ var ClaudeSource = class {
 // src/sources/codex.ts
 import fs15 from "fs";
 import os10 from "os";
-import path18 from "path";
+import path19 from "path";
 import readline2 from "readline";
 async function parseSessionMeta(filePath) {
   const stream = fs15.createReadStream(filePath, { encoding: "utf-8" });
@@ -13584,7 +15139,7 @@ async function findJsonlFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const full = path18.join(d, entry.name);
+      const full = path19.join(d, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -13629,14 +15184,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 = path19.join(os10.homedir(), ".codex");
+    const sessionsDir = path19.join(codexDir, "sessions");
     try {
       await fs15.promises.access(sessionsDir);
     } catch {
       return [];
     }
-    const historyPath = path18.join(codexDir, "history.jsonl");
+    const historyPath = path19.join(codexDir, "history.jsonl");
     const [jsonlFiles, historyMap] = await Promise.all([
       findJsonlFiles(sessionsDir),
       loadHistory(historyPath)
@@ -13659,8 +15214,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 = path19.relative(sessionsDir, path19.dirname(filePath));
+        const historyAbsPath = path19.join(
           sessionsDir,
           sessionDir,
           `history-${meta.sessionId}.jsonl`
@@ -13682,16 +15237,16 @@ var CodexSource = class {
 // src/sources/copilotChat.ts
 import fs16 from "fs";
 import os11 from "os";
-import path19 from "path";
+import path20 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")
+    path20.join(home, "Library", "Application Support", "Code", "User"),
+    path20.join(home, ".config", "Code", "User")
   ];
   if (process.env.APPDATA) {
-    dirs.push(path19.join(process.env.APPDATA, "Code", "User"));
+    dirs.push(path20.join(process.env.APPDATA, "Code", "User"));
   }
   return dirs;
 }
@@ -13728,7 +15283,7 @@ var CopilotChatSource = class {
   async scan() {
     const results = [];
     for (const userDir of vsCodeUserDirs()) {
-      const workspaceStorage = path19.join(userDir, "workspaceStorage");
+      const workspaceStorage = path20.join(userDir, "workspaceStorage");
       let hashDirs;
       try {
         hashDirs = await fs16.promises.readdir(workspaceStorage, {
@@ -13739,8 +15294,8 @@ 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 = path20.join(workspaceStorage, hash.name);
+        const transcriptsDir = path20.join(
           wsRoot,
           "GitHub.copilot-chat",
           "transcripts"
@@ -13754,7 +15309,7 @@ var CopilotChatSource = class {
           continue;
         }
         const repoPath = await readWorkspaceFolder(
-          path19.join(wsRoot, "workspace.json")
+          path20.join(wsRoot, "workspace.json")
         );
         if (!repoPath) continue;
         for (const entry of transcriptEntries) {
@@ -13762,7 +15317,7 @@ var CopilotChatSource = class {
           const sessionId = entry.name.slice(0, -".jsonl".length);
           results.push({
             sourceName: this.name,
-            absolutePath: path19.join(transcriptsDir, entry.name),
+            absolutePath: path20.join(transcriptsDir, entry.name),
             repoPath,
             metadata: { sessionId }
           });
@@ -13829,10 +15384,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 = path21.resolve(repo.root);
   const matching = allGroups.filter((g) => {
-    const resolved = path20.resolve(g.repoPath);
-    return resolved === repoRoot || resolved.startsWith(repoRoot + path20.sep);
+    const resolved = path21.resolve(g.repoPath);
+    return resolved === repoRoot || resolved.startsWith(repoRoot + path21.sep);
   });
   if (matching.length === 0) {
     s.stop(`No ${source.name} logs found for ${repo.name}.`);
@@ -13863,7 +15418,7 @@ async function runInteractive() {
     }
   }
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path20.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path21.join(repoRoot, n));
   const additionalFiles = await promptSecretFiles(envFileNames);
   const secretResult = await collectSecrets(
     repoRoot,