hillclimb 0.2.0 → 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 = 4;
+var OPENCODE_PLUGIN_VERSION = 6;
 var OPENCODE_PLUGIN_MARKER = `// HILLCLIMB_OPENCODE_PLUGIN_VERSION=${OPENCODE_PLUGIN_VERSION}`;
 var OPENCODE_PLUGIN_CONTENT = `${OPENCODE_PLUGIN_MARKER}
 // Auto-installed by \`npx hillclimb\`. Do not edit manually \u2014 re-running
@@ -952,7 +956,10 @@ export const HillclimbPlugin = async ({ directory }) => ({
     const type = event && event.type;
     const props = (event && event.properties) || {};
     const info = props.info || {};
-    const sessionID = props.sessionID || info.sessionID || info.id;
+    const sessionID =
+      props.sessionID ||
+      info.sessionID ||
+      (type === "message.updated" || type === "message.part.updated" ? undefined : info.id);
     const cwd = directory || props.directory || info.directory;
 
     if (type === "message.updated") {
@@ -990,11 +997,8 @@ export const HillclimbPlugin = async ({ directory }) => ({
 
     if (type === "session.deleted" && sessionID) {
       // User explicitly ended this session. Upload its transcript and drop
-      // the buffer. We do NOT clean up git-traces here: the user may still
-      // have other live sessions in this repo, and git-traces state is
-      // keyed per (repoRoot, tool) \u2014 clearing it here would wipe their
-      // concurrent session. Cleanup happens at server.instance.disposed
-      // (or on the next session.created via stale-state detection).
+      // the buffer. git-traces state is session-scoped, so this cleanup will
+      // not wipe another concurrent session in the same repo.
       const transcriptPath = writeTranscript(sessionID);
       if (transcriptPath) {
         spawnHillclimb("upload", {
@@ -1005,15 +1009,19 @@ export const HillclimbPlugin = async ({ directory }) => ({
           tool: TOOL,
         });
       }
+      spawnHillclimb("git-traces --tool=opencode", {
+        session_id: sessionID,
+        cwd,
+        hook_event_name: "session.deleted",
+        tool: TOOL,
+      });
       sessionMessages.delete(sessionID);
       return;
     }
 
     if (type === "server.instance.disposed") {
       // opencode is shutting down \u2014 flush every buffered session's transcript
-      // so nothing gets lost. Then clean up git-traces refs/state. No
-      // sessionID on this event, but git-traces state is keyed by
-      // (repoRoot, tool) so cwd alone is enough for handleSessionEnd.
+      // so nothing gets lost. Then clean up git-traces refs/state per session.
       for (const sid of sessionMessages.keys()) {
         const transcriptPath = writeTranscript(sid);
         if (transcriptPath) {
@@ -1025,8 +1033,15 @@ export const HillclimbPlugin = async ({ directory }) => ({
             tool: TOOL,
           });
         }
+        spawnHillclimb("git-traces --tool=opencode", {
+          session_id: sid,
+          cwd,
+          hook_event_name: "server.instance.disposed",
+          tool: TOOL,
+        });
       }
       sessionMessages.clear();
+      // Keep a no-session cleanup for pre-session-scoped legacy state.
       spawnHillclimb("git-traces --tool=opencode", {
         cwd,
         hook_event_name: "server.instance.disposed",
@@ -1039,16 +1054,16 @@ export const HillclimbPlugin = async ({ directory }) => ({
 
 export default HillclimbPlugin;
 `;
-async function opencodeInstall(file) {
+async function opencodeInstall(file, content = OPENCODE_PLUGIN_CONTENT) {
   try {
     const existing = await fs5.promises.readFile(file, "utf-8");
-    if (existing === OPENCODE_PLUGIN_CONTENT) {
+    if (existing === content) {
       return { installed: 0, alreadyPresent: 1 };
     }
   } catch {
   }
   await fs5.promises.mkdir(path6.dirname(file), { recursive: true });
-  await fs5.promises.writeFile(file, OPENCODE_PLUGIN_CONTENT);
+  await fs5.promises.writeFile(file, content);
   return { installed: 1, alreadyPresent: 0 };
 }
 async function opencodeCheck(file) {
@@ -1079,14 +1094,24 @@ function check(settings, format, eventName, command, options = {}) {
       return claudeCheck(settings, eventName, command, options);
   }
 }
-function uninstall(settings, format, eventName, command) {
+function commandsForEvent(settings, format, eventName) {
   switch (format) {
     case "cursor":
-      return cursorUninstall(settings, eventName, command);
+      return (settings.hooks?.[eventName] ?? []).map((e) => e.command).filter((command) => typeof command === "string");
     case "copilot":
-      return copilotUninstall(settings, eventName, command);
+      return (settings.hooks?.[eventName] ?? []).filter((e) => e.type === "command").map((e) => e.command).filter((command) => typeof command === "string");
     default:
-      return claudeUninstall(settings, eventName, command);
+      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 cursorUninstallMatching(settings, eventName, predicate);
+    case "copilot":
+      return copilotUninstallMatching(settings, eventName, predicate);
+    default:
+      return claudeUninstallMatching(settings, eventName, predicate);
   }
 }
 function legacyCommandsFor(command) {
@@ -1107,6 +1132,20 @@ function legacyCommandsFor(command) {
   }
   return legacy;
 }
+function legacyBareGitTracesCommandsFor(command) {
+  return legacyCommandsFor(command).filter(
+    (legacy) => legacy.endsWith(" git-traces")
+  );
+}
+function isHillclimbOwnedCommandFor(command, currentCommand) {
+  if (command === currentCommand || legacyCommandsFor(currentCommand).includes(command)) {
+    return true;
+  }
+  const prefix = "npx hillclimb@latest ";
+  if (!currentCommand.startsWith(prefix)) return false;
+  const subcommand = currentCommand.slice(prefix.length);
+  return command.endsWith(` ${subcommand}`) && (command.includes(DEV_HOOK_ENV) || command.includes(SKIP_SELF_HEAL_ENV) && command.includes("dist/cli.js"));
+}
 async function installHooksForTool(repoRoot, def) {
   const file = settingsPath(repoRoot, def);
   if (def.format === "opencode") {
@@ -1118,10 +1157,13 @@ async function installHooksForTool(repoRoot, def) {
   let alreadyPresent = 0;
   let mutated = false;
   for (const evt of def.events) {
-    for (const legacy of legacyCommandsFor(evt.command)) {
-      if (uninstall(settings, def.format, evt.eventName, legacy)) {
-        mutated = true;
-      }
+    if (uninstallMatching(
+      settings,
+      def.format,
+      evt.eventName,
+      (command) => command !== evt.command && isHillclimbOwnedCommandFor(command, evt.command)
+    )) {
+      mutated = true;
     }
     const added = install(settings, def.format, evt.eventName, evt.command, {
       timeout: evt.timeout
@@ -1157,6 +1199,27 @@ async function checkHooksForTool(repoRoot, def) {
   }
   return { allInstalled: missing.length === 0, settingsFile: file, missing };
 }
+async function findLegacyGitTracesHookOwners(repoRoot, eventName) {
+  if (!eventName) return [];
+  const owners = [];
+  for (const def of TOOLS) {
+    if (def.format === "opencode") continue;
+    const events = def.events.filter(
+      (evt) => evt.eventName === eventName && evt.command.startsWith("npx hillclimb@latest git-traces --tool=")
+    );
+    if (events.length === 0) continue;
+    const settings = await readJson(settingsPath(repoRoot, def));
+    const commands = new Set(commandsForEvent(settings, def.format, eventName));
+    if (events.some(
+      (evt) => legacyBareGitTracesCommandsFor(evt.command).some(
+        (legacy) => commands.has(legacy)
+      )
+    )) {
+      owners.push(def.tool);
+    }
+  }
+  return owners;
+}
 function detectTools(repoRoot) {
   return TOOLS.filter((def) => def.detect(repoRoot));
 }
@@ -11304,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")) {
@@ -11317,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"]) {
@@ -11434,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;
     }
@@ -11489,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) {
@@ -11524,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] };
     }
@@ -11572,13 +11697,13 @@ function excludeNone(obj) {
 }
 
 // src/normalizer/copilotChat.ts
-function asObject(value) {
+function asObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function asNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function compactExtra(extra) {
+function compactExtra2(extra) {
   const result = {};
   for (const [key, value] of Object.entries(extra)) {
     if (value !== void 0 && value !== null) result[key] = value;
@@ -11591,11 +11716,11 @@ function parseJsonLines(content) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
-      const parsed = asObject(JSON.parse(trimmed));
+      const parsed = asObject2(JSON.parse(trimmed));
       if (!parsed) continue;
       entries.push({
         type: typeof parsed.type === "string" ? parsed.type : void 0,
-        data: asObject(parsed.data),
+        data: asObject2(parsed.data),
         id: typeof parsed.id === "string" ? parsed.id : void 0,
         timestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : void 0
       });
@@ -11605,11 +11730,11 @@ function parseJsonLines(content) {
   return entries;
 }
 function parseArguments(value) {
-  const obj = asObject(value);
+  const obj = asObject2(value);
   if (obj) return obj;
   if (typeof value === "string") {
     try {
-      const parsed = asObject(JSON.parse(value));
+      const parsed = asObject2(JSON.parse(value));
       if (parsed) return parsed;
     } catch {
       return value ? { input: value } : {};
@@ -11631,7 +11756,7 @@ function buildMetrics2(data) {
     completion_tokens: outputTokens || void 0,
     cached_tokens: cacheReadTokens || void 0,
     cost_usd: cost || void 0,
-    extra: compactExtra({
+    extra: compactExtra2({
       cache_write_tokens: cacheWriteTokens || void 0,
       duration_ms: data.duration,
       initiator: data.initiator,
@@ -11663,7 +11788,7 @@ function finalMetricsFromSteps(steps) {
   };
 }
 function makeToolCall(request) {
-  const req = asObject(request);
+  const req = asObject2(request);
   if (!req) return null;
   const callId = typeof req.toolCallId === "string" && req.toolCallId || typeof req.id === "string" && req.id || "";
   const name = typeof req.name === "string" && req.name || typeof req.toolName === "string" && req.toolName || "tool";
@@ -11683,7 +11808,7 @@ function toolCallFromExecutionStart(data) {
   };
 }
 function contentFromToolResult(data) {
-  const result = asObject(data.result);
+  const result = asObject2(data.result);
   if (typeof result?.content === "string") return result.content;
   if (typeof data.content === "string") return data.content;
   return void 0;
@@ -11709,7 +11834,7 @@ function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
         copilotVersion = data.copilotVersion;
       if (typeof data.vscodeVersion === "string")
         vscodeVersion = data.vscodeVersion;
-      const context = asObject(data.context);
+      const context = asObject2(data.context);
       if (typeof context?.cwd === "string") cwd = context.cwd;
       continue;
     }
@@ -11722,7 +11847,7 @@ function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
         timestamp: entry.timestamp,
         source,
         message: content,
-        extra: compactExtra({
+        extra: compactExtra2({
           attachments: data.attachments,
           source: data.source,
           agent_mode: data.agentMode,
@@ -11752,7 +11877,7 @@ function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
         source: "agent",
         message: content || (toolCalls.length > 0 ? "(tool use)" : ""),
         model_name: defaultModelName,
-        extra: compactExtra({
+        extra: compactExtra2({
           message_id: data.messageId,
           phase: data.phase,
           output_tokens: data.outputTokens
@@ -11798,7 +11923,7 @@ function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
         target.observation = observation;
         const extra = { ...target.extra ?? {} };
         extra.tool_success = data.success;
-        target.extra = compactExtra(extra);
+        target.extra = compactExtra2(extra);
       }
       if (callId) pendingToolSteps.delete(callId);
       continue;
@@ -11824,7 +11949,7 @@ function convertCopilotChatToTrajectory(jsonlContent, sessionId) {
       name: "github-copilot-chat",
       version: copilotVersion,
       model_name: defaultModelName,
-      extra: compactExtra({
+      extra: compactExtra2({
         vscode_version: vscodeVersion,
         cwd
       })
@@ -11892,7 +12017,7 @@ function convertCursorToTrajectory(jsonlContent, sessionId) {
 }
 
 // src/normalizer/opencode.ts
-function asObject2(value) {
+function asObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function asArray(value) {
@@ -11901,7 +12026,7 @@ function asArray(value) {
 function asNumber2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function compactExtra2(extra) {
+function compactExtra3(extra) {
   const result = {};
   for (const [key, value] of Object.entries(extra)) {
     if (value !== void 0 && value !== null) result[key] = value;
@@ -11915,7 +12040,7 @@ function parseJsonLines2(content) {
     if (!trimmed) continue;
     try {
       const parsed = JSON.parse(trimmed);
-      const obj = asObject2(parsed);
+      const obj = asObject3(parsed);
       if (obj) events.push(obj);
     } catch {
     }
@@ -11930,7 +12055,7 @@ function timestampToIso(value) {
   return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
 }
 function timeFromObject(value) {
-  const obj = asObject2(value);
+  const obj = asObject3(value);
   if (!obj) return void 0;
   return timestampToIso(obj.start ?? obj.created ?? obj.completed ?? obj.end);
 }
@@ -11943,12 +12068,12 @@ function stringify2(value) {
   }
 }
 function argsFromUnknown(value) {
-  const obj = asObject2(value);
+  const obj = asObject3(value);
   if (obj) return obj;
   if (typeof value === "string") {
     try {
       const parsed = JSON.parse(value);
-      const parsedObj = asObject2(parsed);
+      const parsedObj = asObject3(parsed);
       if (parsedObj) return parsedObj;
     } catch {
       return value ? { input: value } : {};
@@ -11957,16 +12082,16 @@ function argsFromUnknown(value) {
   return value === void 0 || value === null ? {} : { value };
 }
 function modelNameFromInfo(info) {
-  const model = asObject2(info.model);
+  const model = asObject3(info.model);
   const modelID = typeof info.modelID === "string" && info.modelID || typeof model?.modelID === "string" && model.modelID || void 0;
   const providerID = typeof info.providerID === "string" && info.providerID || typeof model?.providerID === "string" && model.providerID || void 0;
   if (providerID && modelID) return `${providerID}/${modelID}`;
   return modelID;
 }
 function metricsFromTokens(tokens, cost) {
-  const t = asObject2(tokens);
+  const t = asObject3(tokens);
   if (!t) return void 0;
-  const cache = asObject2(t.cache);
+  const cache = asObject3(t.cache);
   const input = asNumber2(t.input) ?? 0;
   const output = asNumber2(t.output) ?? 0;
   const reasoning = asNumber2(t.reasoning) ?? 0;
@@ -11976,7 +12101,7 @@ function metricsFromTokens(tokens, cost) {
   if (!input && !output && !cacheRead && !cacheWrite && !costUsd) {
     return void 0;
   }
-  const extra = compactExtra2({
+  const extra = compactExtra3({
     reasoning_tokens: reasoning || void 0,
     cache_write_tokens: cacheWrite || void 0
   });
@@ -12017,12 +12142,12 @@ function finalMetricsFromSteps2(steps) {
   };
 }
 function entryFromLine(line) {
-  const info = asObject2(line.info);
+  const info = asObject3(line.info);
   if (info) {
     return {
       info,
       parts: asArray(line.parts).flatMap((part) => {
-        const obj = asObject2(part);
+        const obj = asObject3(part);
         return obj ? [obj] : [];
       })
     };
@@ -12031,7 +12156,7 @@ function entryFromLine(line) {
     return {
       info: line,
       parts: asArray(line.parts).flatMap((part) => {
-        const obj = asObject2(part);
+        const obj = asObject3(part);
         return obj ? [obj] : [];
       })
     };
@@ -12050,9 +12175,9 @@ function entriesFromEventWrappers(lines) {
   }
   for (const line of lines) {
     const type = line.type;
-    const props = asObject2(line.properties) ?? line;
+    const props = asObject3(line.properties) ?? line;
     if (type === "message.updated") {
-      const info = asObject2(props.info);
+      const info = asObject3(props.info);
       const id = typeof info?.id === "string" ? info.id : void 0;
       if (!info || !id) continue;
       const entry = getEntry(id, info.sessionID);
@@ -12060,7 +12185,7 @@ function entriesFromEventWrappers(lines) {
       continue;
     }
     if (type === "message.part.updated") {
-      const part = asObject2(props.part);
+      const part = asObject3(props.part);
       const messageID = typeof part?.messageID === "string" && part.messageID || void 0;
       if (!part || !messageID) continue;
       const entry = getEntry(messageID, part.sessionID);
@@ -12085,8 +12210,8 @@ function getAgentVersion(exportInfo) {
 }
 function sortEntries(entries) {
   return [...entries].sort((a, b) => {
-    const at = asNumber2(asObject2(a.info.time)?.created) ?? 0;
-    const bt = asNumber2(asObject2(b.info.time)?.created) ?? 0;
+    const at = asNumber2(asObject3(a.info.time)?.created) ?? 0;
+    const bt = asNumber2(asObject3(b.info.time)?.created) ?? 0;
     return at - bt;
   });
 }
@@ -12143,7 +12268,7 @@ function buildUserStep(entry, stepId, defaultModelName) {
     source: "user",
     message,
     model_name: defaultModelName,
-    extra: compactExtra2(extra)
+    extra: compactExtra3(extra)
   };
 }
 function buildAgentStep(parts, info, stepId, defaultModelName, fallbackMetrics) {
@@ -12173,7 +12298,7 @@ function buildAgentStep(parts, info, stepId, defaultModelName, fallbackMetrics)
         break;
       }
       case "tool": {
-        const state = asObject2(part.state) ?? {};
+        const state = asObject3(part.state) ?? {};
         const callID = typeof part.callID === "string" && part.callID || typeof part.id === "string" && part.id || "";
         const toolName = typeof part.tool === "string" && part.tool || "tool";
         const input = argsFromUnknown(state.input);
@@ -12227,7 +12352,7 @@ function buildAgentStep(parts, info, stepId, defaultModelName, fallbackMetrics)
   if (toolCalls.length > 0) step.tool_calls = toolCalls;
   if (observation) step.observation = observation;
   if (metrics) step.metrics = metrics;
-  const compactedExtra = compactExtra2(extra);
+  const compactedExtra = compactExtra3(extra);
   if (compactedExtra) step.extra = compactedExtra;
   return step;
 }
@@ -12243,7 +12368,7 @@ function buildUnavailableAgentStep(info, stepId, defaultModelName) {
     message: "(message unavailable)",
     model_name: modelNameFromInfo(info) ?? defaultModelName,
     metrics,
-    extra: compactExtra2({
+    extra: compactExtra3({
       content_unavailable: true,
       finish_reason: info.finish,
       error: info.error
@@ -12313,14 +12438,14 @@ function convertRunEventsToTrajectory(events, sessionId) {
     }
     if (type === "step_finish") {
       if (current) {
-        current.finish = asObject2(event.part) ?? {};
+        current.finish = asObject3(event.part) ?? {};
         turns.push(current);
         current = null;
       }
       continue;
     }
     if (current && (type === "text" || type === "reasoning" || type === "tool_use")) {
-      const part = asObject2(event.part);
+      const part = asObject3(event.part);
       if (part) current.parts.push(part);
     }
   }
@@ -12362,17 +12487,17 @@ function convertOpenCodeToTrajectory(content, sessionId) {
   if (!trimmed) return null;
   try {
     const parsed = JSON.parse(trimmed);
-    const parsedObj = asObject2(parsed);
+    const parsedObj = asObject3(parsed);
     const messages = asArray(parsedObj?.messages);
     if (parsedObj && messages.length > 0) {
       const entries2 = messages.flatMap((message) => {
-        const entry = entryFromLine(asObject2(message) ?? {});
+        const entry = entryFromLine(asObject3(message) ?? {});
         return entry ? [entry] : [];
       });
       return convertMessageEntriesToTrajectory(
         entries2,
         sessionId,
-        asObject2(parsedObj.info)
+        asObject3(parsedObj.info)
       );
     }
   } catch {
@@ -12418,7 +12543,7 @@ var NormalizeMiddleware = class {
         continue;
       const content = file.content ? file.content.toString("utf-8") : null;
       if (!content) continue;
-      const sessionId = file.metadata?.sessionId ?? path9.basename(file.absolutePath, ".jsonl");
+      const sessionId = file.metadata?.sessionId ?? (file.sourceName === "codex" ? void 0 : path9.basename(file.absolutePath, ".jsonl"));
       try {
         const trajectory = normalizeContent(
           file.sourceName,
@@ -12676,6 +12801,7 @@ function resolveSourceTool(payload) {
   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) {
@@ -12958,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";
@@ -13212,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;
@@ -13328,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")) {
@@ -13361,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}`,
@@ -13388,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;
@@ -13411,24 +13577,112 @@ async function readSessionState(repoRoot, tool) {
     return null;
   }
 }
+async function listScopedSessionStates(repoRoot, tool) {
+  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 (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);
-  await fs11.promises.mkdir(STATE_DIR, { recursive: true, mode: 448 });
+  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 deleteSessionState(repoRoot, tool) {
+async function deleteStateFile(file) {
   try {
-    await fs11.promises.unlink(stateFileForRepo(repoRoot, tool));
+    await fs11.promises.unlink(file);
   } catch {
   }
 }
-async function acquireLock(repoRoot, tool, retries = 3, delayMs = 200) {
+async function deleteSessionState(repoRoot, tool, sessionId) {
+  if (sessionId) {
+    await deleteStateFile(stateFileForRepo(repoRoot, tool, sessionId));
+    const legacyFile = stateFileForRepo(repoRoot, tool);
+    const legacy = await readStateFile(legacyFile);
+    if (legacy?.sessionId === sessionId) {
+      await deleteStateFile(legacyFile);
+    }
+    return;
+  }
+  await deleteStateFile(stateFileForRepo(repoRoot, tool));
+}
+async function acquireLock(repoRoot, tool, retries = LOCK_RETRIES, delayMs = LOCK_RETRY_DELAY_MS) {
   const lockPath = lockFileForRepo(repoRoot, tool);
-  await fs11.promises.mkdir(STATE_DIR, { recursive: true, mode: 448 });
+  await fs11.promises.mkdir(stateDir(), { recursive: true, mode: 448 });
   for (let i = 0; i < retries; i++) {
     try {
       const fd = await fs11.promises.open(
@@ -13459,6 +13713,7 @@ async function releaseLock(repoRoot, tool) {
 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));
 }
@@ -13469,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;
 }
@@ -13528,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,
@@ -13560,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(
@@ -13576,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);
@@ -13596,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;
@@ -13619,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);
@@ -13665,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,
@@ -13781,7 +14247,7 @@ Uploaded: ${now.toISOString()}`
         transitionKind,
         startedAt: state.startedAt
       });
-      if (!artifacts) return;
+      if (!artifacts) return "failed";
       const next = {
         ...state,
         baselineSha: artifacts.baselineSha,
@@ -13793,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";
@@ -13868,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];
@@ -13887,25 +14510,91 @@ async function readStdin2() {
 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;
-    const result = await healHookForTool(project.repoRoot, tool);
-    if (result.skipped) {
-      appendLog("warn", `self-heal: skipped ${tool} hook (${result.skipped})`);
-      return;
+    await repairHookForTool(project.repoRoot, tool);
+  } catch (err) {
+    appendLog(
+      "warn",
+      `self-heal: failed to repair ${tool} hook: ${formatError(err)}`
+    );
+  }
+}
+async function resolveLegacyBareTool(raw) {
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch (err) {
+    appendLog(
+      "error",
+      `git-traces: missing --tool and failed to parse payload for legacy hook repair: ${formatError(err)}`
+    );
+    return null;
+  }
+  const cwd = 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;
     }
-    if (result.changed) {
-      appendLog("info", `self-heal: updated ${tool} hook`);
+    const owners = await findLegacyGitTracesHookOwners(
+      project.repoRoot,
+      payload.hook_event_name
+    );
+    if (owners.length === 0) {
+      appendLog(
+        "error",
+        `git-traces: missing --tool and no legacy bare git-traces hook matched event ${payload.hook_event_name ?? "<none>"}`
+      );
+      return null;
+    }
+    for (const owner of owners) {
+      await repairHookForTool(project.repoRoot, owner);
     }
+    if (owners.length > 1) {
+      appendLog(
+        "warn",
+        `git-traces: legacy bare hook matched multiple tools (${owners.join(", ")}); repaired hooks but skipped this event`
+      );
+      return null;
+    }
+    appendLog(
+      "info",
+      `git-traces: inferred legacy bare hook owner ${owners[0]} and repaired hook`
+    );
+    return owners[0];
   } catch (err) {
     appendLog(
       "warn",
-      `self-heal: failed to repair ${tool} hook: ${formatError(err)}`
+      `git-traces: failed legacy hook repair: ${formatError(err)}`
     );
+    return null;
   }
 }
 async function runGitTraces() {
@@ -13920,13 +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();
@@ -13938,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");
@@ -13946,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
         }
       }
@@ -14024,25 +14715,14 @@ async function runGitTracesWorker() {
   }
   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:
@@ -14061,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") {
@@ -14081,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;
 }
@@ -14091,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;
@@ -14105,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);
@@ -14307,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);
@@ -14326,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);
     }
@@ -14372,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);
@@ -14394,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 {
@@ -14406,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(
@@ -14426,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" });
@@ -14459,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")) {
@@ -14504,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)
@@ -14534,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`
@@ -14557,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;
 }
@@ -14603,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, {
@@ -14614,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"
@@ -14629,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) {
@@ -14637,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 }
           });
@@ -14704,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}.`);
@@ -14738,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,