hillclimb 0.1.2 → 0.1.4

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs15 from "fs";
-import path18 from "path";
+import fs16 from "fs";
+import path19 from "path";
 import * as p6 from "@clack/prompts";
 
 // src/commands/init.ts
@@ -146,6 +146,97 @@ async function clearIdentity(apiBaseUrl) {
   return true;
 }
 
+// src/platform/error-format.ts
+function formatError(err) {
+  if (!(err instanceof Error)) return String(err);
+  const parts = [err.message || err.name];
+  const status = err.status;
+  const code = err.code;
+  if (typeof status === "number") parts.push(`status=${status}`);
+  if (typeof code === "string" && code) parts.push(`code=${code}`);
+  if (err.cause !== void 0 && err.cause !== null) {
+    const causeMsg = err.cause instanceof Error ? err.cause.message : String(err.cause);
+    if (causeMsg) parts.push(`cause=${causeMsg}`);
+  }
+  return parts.join(" ");
+}
+
+// src/platform/log.ts
+import fs3 from "fs";
+import path4 from "path";
+var PT_TIME_ZONE = "America/Los_Angeles";
+function pacificParts(date) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: PT_TIME_ZONE,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  }).formatToParts(date);
+  const lookup = {};
+  for (const p7 of parts) if (p7.type !== "literal") lookup[p7.type] = p7.value;
+  if (lookup.hour === "24") lookup.hour = "00";
+  return {
+    year: lookup.year ?? "0000",
+    month: lookup.month ?? "00",
+    day: lookup.day ?? "00",
+    hour: lookup.hour ?? "00",
+    minute: lookup.minute ?? "00",
+    second: lookup.second ?? "00"
+  };
+}
+function pacificOffsetMinutes(date) {
+  const p7 = pacificParts(date);
+  const asIfUtc = Date.UTC(
+    Number(p7.year),
+    Number(p7.month) - 1,
+    Number(p7.day),
+    Number(p7.hour),
+    Number(p7.minute),
+    Number(p7.second)
+  );
+  return Math.round((asIfUtc - date.getTime()) / 6e4);
+}
+function pacificTimestamp(date) {
+  const p7 = pacificParts(date);
+  const ms = String(date.getMilliseconds()).padStart(3, "0");
+  const off = pacificOffsetMinutes(date);
+  const sign = off >= 0 ? "+" : "-";
+  const abs = Math.abs(off);
+  const oh = String(Math.floor(abs / 60)).padStart(2, "0");
+  const om = String(abs % 60).padStart(2, "0");
+  return `${p7.year}-${p7.month}-${p7.day}T${p7.hour}:${p7.minute}:${p7.second}.${ms}${sign}${oh}:${om}`;
+}
+function pacificDateString(date) {
+  const p7 = pacificParts(date);
+  return `${p7.year}-${p7.month}-${p7.day}`;
+}
+function logsDir() {
+  return path4.join(configDir(), "logs");
+}
+function todayLogPath() {
+  return path4.join(logsDir(), `${pacificDateString(/* @__PURE__ */ new Date())}.log`);
+}
+var logPrefix = "";
+function setLogPrefix(prefix) {
+  logPrefix = prefix;
+}
+function appendLog(level, message) {
+  const tag = logPrefix ? ` ${logPrefix}` : "";
+  const line = `[${pacificTimestamp(/* @__PURE__ */ new Date())}] [${level}]${tag} ${message}
+`;
+  try {
+    fs3.mkdirSync(logsDir(), { recursive: true, mode: 448 });
+    fs3.appendFileSync(todayLogPath(), line);
+  } catch {
+    process.stderr.write(`hillclimb:${tag} ${level}: ${message}
+`);
+  }
+}
+
 // src/platform/client.ts
 var PlatformError = class extends Error {
   constructor(message, status, code) {
@@ -229,9 +320,21 @@ var PlatformClient = class {
     if (body !== void 0) {
       init.body = JSON.stringify(body);
     }
-    const res = await fetch(this.url(relative), init);
+    const start = Date.now();
+    let res;
+    try {
+      res = await fetch(this.url(relative), init);
+    } catch (err) {
+      appendLog(
+        "error",
+        `[${method} ${relative}] FAILED ${Date.now() - start}ms ${formatError(err)}`
+      );
+      throw err;
+    }
+    const elapsedMs = Date.now() - start;
     this.mergeSetCookies(res);
     if (!res.ok) {
+      appendLog("warn", `[${method} ${relative}] ${res.status} ${elapsedMs}ms`);
       let code;
       let message = `${method} ${relative} failed: HTTP ${res.status}`;
       try {
@@ -253,6 +356,7 @@ var PlatformClient = class {
       }
       throw new PlatformError(message, res.status, code);
     }
+    appendLog("info", `[${method} ${relative}] ${res.status} ${elapsedMs}ms`);
     if (res.status === 204) {
       return void 0;
     }
@@ -337,12 +441,31 @@ var PlatformClient = class {
   async uploadToPresignedUrl(presignedUrl, headers, body) {
     const ab = new ArrayBuffer(body.byteLength);
     new Uint8Array(ab).set(body);
-    const res = await fetch(presignedUrl, {
-      method: "PUT",
-      headers,
-      body: new Blob([ab])
-    });
+    const host = (() => {
+      try {
+        return new URL(presignedUrl).host;
+      } catch {
+        return "presigned-url";
+      }
+    })();
+    const start = Date.now();
+    let res;
+    try {
+      res = await fetch(presignedUrl, {
+        method: "PUT",
+        headers,
+        body: new Blob([ab])
+      });
+    } catch (err) {
+      appendLog(
+        "error",
+        `[PUT ${host}] FAILED ${Date.now() - start}ms ${formatError(err)}`
+      );
+      throw err;
+    }
+    const elapsedMs = Date.now() - start;
     if (!res.ok) {
+      appendLog("warn", `[PUT ${host}] ${res.status} ${elapsedMs}ms`);
       let detail = "";
       try {
         detail = await res.text();
@@ -353,6 +476,10 @@ var PlatformClient = class {
         res.status
       );
     }
+    appendLog(
+      "info",
+      `[PUT ${host}] ${res.status} ${elapsedMs}ms (${body.byteLength} bytes)`
+    );
   }
   async submitContribution(contributionId) {
     const data = await this.request(
@@ -377,9 +504,9 @@ var PlatformClient = class {
 };
 
 // src/platform/hooks.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import os2 from "os";
-import path4 from "path";
+import path5 from "path";
 var HOOK_CMD = (sub) => `npx hillclimb ${sub}`;
 var GIT_TRACES_CMD = (tool) => `npx hillclimb git-traces --tool=${tool}`;
 var TOOLS = [
@@ -394,7 +521,7 @@ var TOOLS = [
       { eventName: "Stop", command: GIT_TRACES_CMD("claude") },
       { eventName: "SessionEnd", command: GIT_TRACES_CMD("claude") }
     ],
-    detect: () => isDir(path4.join(os2.homedir(), ".claude"))
+    detect: () => isDir(path5.join(os2.homedir(), ".claude"))
   },
   {
     tool: "cursor",
@@ -407,7 +534,7 @@ var TOOLS = [
       { eventName: "stop", command: GIT_TRACES_CMD("cursor") },
       { eventName: "sessionEnd", command: GIT_TRACES_CMD("cursor") }
     ],
-    detect: () => isDir(path4.join(os2.homedir(), ".cursor"))
+    detect: () => isDir(path5.join(os2.homedir(), ".cursor"))
   },
   {
     // opencode has no settings-file hook system (the `experimental.hook` block
@@ -422,7 +549,28 @@ var TOOLS = [
     format: "opencode",
     events: [],
     // Events are wired inside the plugin itself; see OPENCODE_PLUGIN_CONTENT.
-    detect: () => isDir(path4.join(os2.homedir(), ".local", "share", "opencode")) || isDir(path4.join(os2.homedir(), ".config", "opencode"))
+    detect: () => isDir(path5.join(os2.homedir(), ".local", "share", "opencode")) || isDir(path5.join(os2.homedir(), ".config", "opencode"))
+  },
+  {
+    // VS Code Copilot Chat. Same "no SessionEnd" constraint as Codex (the
+    // event is documented but never fires — VS Code issue microsoft/vscode#300650).
+    // Stale-state cleanup happens on next SessionStart, like Codex.
+    // Hook config lives at .github/hooks/hooks.json — distinct from
+    // .claude/settings.local.json so Claude Code and Copilot Chat don't
+    // fire each other's hooks even though VS Code's docs claim they share.
+    tool: "copilot-chat",
+    label: "GitHub Copilot Chat",
+    settingsFile: ".github/hooks/hooks.json",
+    format: "copilot",
+    events: [
+      { eventName: "SessionStart", command: GIT_TRACES_CMD("copilot-chat") },
+      { eventName: "Stop", command: GIT_TRACES_CMD("copilot-chat") },
+      {
+        eventName: "Stop",
+        command: `${HOOK_CMD("upload")} --tool=copilot-chat`
+      }
+    ],
+    detect: copilotChatDetect
   },
   {
     // Codex has no SessionEnd hook (only SessionStart, PreToolUse, PostToolUse,
@@ -441,22 +589,36 @@ var TOOLS = [
       { eventName: "SessionStart", command: GIT_TRACES_CMD("codex") },
       { eventName: "Stop", command: GIT_TRACES_CMD("codex") }
     ],
-    detect: () => isDir(path4.join(os2.homedir(), ".codex"))
+    detect: () => isDir(path5.join(os2.homedir(), ".codex"))
   }
 ];
 function isDir(p7) {
   try {
-    return fs3.statSync(p7).isDirectory();
+    return fs4.statSync(p7).isDirectory();
   } catch {
     return false;
   }
 }
+function copilotChatDetect() {
+  const home = os2.homedir();
+  const suffix = path5.join(
+    "User",
+    "globalStorage",
+    "github.copilot-chat"
+  );
+  const candidates = [
+    path5.join(home, "Library", "Application Support", "Code", suffix),
+    path5.join(home, ".config", "Code", suffix),
+    process.env.APPDATA ? path5.join(process.env.APPDATA, "Code", suffix) : null
+  ].filter((p7) => p7 !== null);
+  return candidates.some(isDir);
+}
 function settingsPath(repoRoot, def) {
-  return path4.join(repoRoot, def.settingsFile);
+  return path5.join(repoRoot, def.settingsFile);
 }
 async function readJson(file) {
   try {
-    const raw = await fs3.promises.readFile(file, "utf-8");
+    const raw = await fs4.promises.readFile(file, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
     return {};
@@ -466,8 +628,8 @@ async function readJson(file) {
   }
 }
 async function writeJson(file, obj) {
-  await fs3.promises.mkdir(path4.dirname(file), { recursive: true });
-  await fs3.promises.writeFile(file, `${JSON.stringify(obj, null, 2)}
+  await fs4.promises.mkdir(path5.dirname(file), { recursive: true });
+  await fs4.promises.writeFile(file, `${JSON.stringify(obj, null, 2)}
 `);
 }
 function claudeHookPresent(matchers, command) {
@@ -545,11 +707,41 @@ function cursorUninstall(settings, eventName, command) {
   }
   return true;
 }
+function copilotHookPresent(entries, command) {
+  return entries.some((e) => e.type === "command" && e.command === command);
+}
+function copilotInstall(settings, eventName, command) {
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks[eventName]) settings.hooks[eventName] = [];
+  const entries = settings.hooks[eventName];
+  if (copilotHookPresent(entries, command)) return false;
+  entries.push({ type: "command", command });
+  return true;
+}
+function copilotCheck(settings, eventName, command) {
+  const entries = settings.hooks?.[eventName] ?? [];
+  return copilotHookPresent(entries, command);
+}
+function copilotUninstall(settings, eventName, command) {
+  const entries = settings.hooks?.[eventName];
+  if (!entries || entries.length === 0) return false;
+  const next = entries.filter(
+    (e) => !(e.type === "command" && e.command === command)
+  );
+  if (next.length === entries.length) return false;
+  if (next.length > 0) {
+    settings.hooks[eventName] = next;
+  } else {
+    delete settings.hooks[eventName];
+    if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+  }
+  return true;
+}
 var OPENCODE_PLUGIN_VERSION = 2;
 var OPENCODE_PLUGIN_MARKER = `// HILLCLIMB_OPENCODE_PLUGIN_VERSION=${OPENCODE_PLUGIN_VERSION}`;
 var OPENCODE_PLUGIN_CONTENT = `${OPENCODE_PLUGIN_MARKER}
-// Auto-installed by \`npx hillclimb init\`. Do not edit manually \u2014 re-running
-// init will overwrite this file. See https://github.com/hillclimbai for context.
+// Auto-installed by \`npx hillclimb\`. Do not edit manually \u2014 re-running
+// hillclimb will overwrite this file. See https://github.com/hillclimbai for context.
 
 import { spawn } from "node:child_process";
 import fs from "node:fs";
@@ -695,32 +887,53 @@ export default HillclimbPlugin;
 `;
 async function opencodeInstall(file) {
   try {
-    const existing = await fs3.promises.readFile(file, "utf-8");
+    const existing = await fs4.promises.readFile(file, "utf-8");
     if (existing === OPENCODE_PLUGIN_CONTENT) {
       return { installed: 0, alreadyPresent: 1 };
     }
   } catch {
   }
-  await fs3.promises.mkdir(path4.dirname(file), { recursive: true });
-  await fs3.promises.writeFile(file, OPENCODE_PLUGIN_CONTENT);
+  await fs4.promises.mkdir(path5.dirname(file), { recursive: true });
+  await fs4.promises.writeFile(file, OPENCODE_PLUGIN_CONTENT);
   return { installed: 1, alreadyPresent: 0 };
 }
 async function opencodeCheck(file) {
   try {
-    const content = await fs3.promises.readFile(file, "utf-8");
+    const content = await fs4.promises.readFile(file, "utf-8");
     return content.includes(OPENCODE_PLUGIN_MARKER);
   } catch {
     return false;
   }
 }
 function install(settings, format, eventName, command) {
-  return format === "cursor" ? cursorInstall(settings, eventName, command) : claudeInstall(settings, eventName, command);
+  switch (format) {
+    case "cursor":
+      return cursorInstall(settings, eventName, command);
+    case "copilot":
+      return copilotInstall(settings, eventName, command);
+    default:
+      return claudeInstall(settings, eventName, command);
+  }
 }
 function check(settings, format, eventName, command) {
-  return format === "cursor" ? cursorCheck(settings, eventName, command) : claudeCheck(settings, eventName, command);
+  switch (format) {
+    case "cursor":
+      return cursorCheck(settings, eventName, command);
+    case "copilot":
+      return copilotCheck(settings, eventName, command);
+    default:
+      return claudeCheck(settings, eventName, command);
+  }
 }
 function uninstall(settings, format, eventName, command) {
-  return format === "cursor" ? cursorUninstall(settings, eventName, command) : claudeUninstall(settings, eventName, command);
+  switch (format) {
+    case "cursor":
+      return cursorUninstall(settings, eventName, command);
+    case "copilot":
+      return copilotUninstall(settings, eventName, command);
+    default:
+      return claudeUninstall(settings, eventName, command);
+  }
 }
 function legacyCommandsFor(command) {
   const prefix = "npx hillclimb ";
@@ -814,17 +1027,17 @@ async function checkAllHooks(repoRoot) {
   }
   return results;
 }
-var CODEX_CONFIG_PATH = path4.join(os2.homedir(), ".codex", "config.toml");
+var CODEX_CONFIG_PATH = path5.join(os2.homedir(), ".codex", "config.toml");
 async function ensureCodexHooksEnabled() {
   let content;
   try {
-    content = await fs3.promises.readFile(CODEX_CONFIG_PATH, "utf-8");
+    content = await fs4.promises.readFile(CODEX_CONFIG_PATH, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
-      await fs3.promises.mkdir(path4.dirname(CODEX_CONFIG_PATH), {
+      await fs4.promises.mkdir(path5.dirname(CODEX_CONFIG_PATH), {
         recursive: true
       });
-      await fs3.promises.writeFile(
+      await fs4.promises.writeFile(
         CODEX_CONFIG_PATH,
         "[features]\ncodex_hooks = true\n"
       );
@@ -840,7 +1053,7 @@ async function ensureCodexHooksEnabled() {
   } else {
     content = content.trimEnd() + "\n\n[features]\ncodex_hooks = true\n";
   }
-  await fs3.promises.writeFile(CODEX_CONFIG_PATH, content);
+  await fs4.promises.writeFile(CODEX_CONFIG_PATH, content);
   return true;
 }
 var CLAUDE_DEF = TOOLS[0];
@@ -896,8 +1109,10 @@ function openBrowser(url) {
 }
 async function webAuth(apiBaseUrl) {
   if (!IS_TTY) {
+    appendLog("info", "web-auth: skipped (not a TTY)");
     return null;
   }
+  appendLog("info", `web-auth: started (apiBaseUrl=${apiBaseUrl})`);
   const client = new PlatformClient(apiBaseUrl);
   const codeResponse = await withSpinner(
     "Preparing web authentication...",
@@ -905,6 +1120,10 @@ async function webAuth(apiBaseUrl) {
     "Could not start web authentication.",
     () => client.createCliAuthCode()
   );
+  appendLog(
+    "info",
+    `web-auth: code prepared (expiresIn=${codeResponse.expiresIn}s, pollInterval=${codeResponse.interval}s)`
+  );
   const url = codeResponse.verificationUrl;
   openBrowser(url);
   p2.log.info(`Opening browser to: ${cyan(url)}`);
@@ -918,6 +1137,7 @@ async function webAuth(apiBaseUrl) {
     try {
       const poll = await client.pollCliAuthCode(codeResponse.code);
       if (poll.status === "approved" && poll.sessionToken) {
+        appendLog("info", "web-auth: authorized");
         spinner5.stop("Authorized.");
         const secure = apiBaseUrl.startsWith("https://");
         const cookieName = secure ? "__Secure-better-auth.session_token" : "better-auth.session_token";
@@ -933,6 +1153,10 @@ async function webAuth(apiBaseUrl) {
             return data;
           }
         );
+        appendLog(
+          "info",
+          `web-auth: completed (email=${bootstrap.session.email})`
+        );
         return {
           client,
           sessionCookie,
@@ -941,13 +1165,16 @@ async function webAuth(apiBaseUrl) {
         };
       }
       if (poll.status === "expired") {
+        appendLog("warn", "web-auth: code expired before authorization");
         spinner5.stop("Authorization expired.");
         p2.log.warn("The authorization code expired. Please try again.");
         return null;
       }
-    } catch {
+    } catch (err) {
+      appendLog("warn", `web-auth: poll attempt failed: ${formatError(err)}`);
     }
   }
+  appendLog("warn", "web-auth: timed out waiting for authorization");
   spinner5.stop("Authorization timed out.");
   p2.log.warn("Timed out waiting for browser authorization.");
   return null;
@@ -1001,16 +1228,20 @@ async function tryReuseIdentity(apiBaseUrl, client, identity) {
 async function runInit(args = []) {
   const forceLogin = args.includes("--login");
   const workspaceSlugFlag = parseStringFlag(args, "workspace");
-  p3.intro("hillclimb init");
+  appendLog(
+    "info",
+    `init: started (cwd=${process.cwd()}, forceLogin=${forceLogin}, workspaceSlug=${workspaceSlugFlag ?? "<none>"})`
+  );
+  p3.intro("hillclimb");
   const repo = detectRepoRoot();
   if (!repo) {
-    p3.log.error(
-      "Not a git repository. Run `npx hillclimb init` inside a repo."
-    );
+    appendLog("error", "init: not a git repository, aborting");
+    p3.log.error("Not a git repository. Run `npx hillclimb` inside a repo.");
     p3.outro("Aborted.");
     process.exit(1);
   }
   const { root: repoRoot, name: repoName } = repo;
+  appendLog("info", `init: repo detected (root=${repoRoot}, name=${repoName})`);
   p3.log.info(`Repo: ${repoName} (${repoRoot})`);
   const apiBaseUrl = resolveDefaultApiUrl();
   const saved = forceLogin ? null : await loadIdentity(apiBaseUrl);
@@ -1040,9 +1271,11 @@ async function runInit(args = []) {
       }
       method = selected;
     }
+    appendLog("info", `init: auth method selected (${method})`);
     if (method === "web") {
       const result = await webAuth(apiBaseUrl);
       if (!result) {
+        appendLog("error", "init: web authentication failed");
         p3.log.error("Web authentication failed.");
         p3.outro("Aborted.");
         process.exit(1);
@@ -1107,6 +1340,10 @@ async function runInit(args = []) {
     }
     pickedId = resolved.organizationId;
     workspace = resolved;
+    appendLog(
+      "info",
+      `init: workspace pre-scoped (slug=${workspaceSlugFlag}, id=${resolved.id}, orgId=${pickedId})`
+    );
     const belongs = orgs.some((o) => o.id === pickedId);
     if (!belongs && !isAdmin) {
       p3.log.error(
@@ -1123,6 +1360,7 @@ async function runInit(args = []) {
           await client.setActiveOrganization(pickedId);
         }
       } catch (err) {
+        appendLog("error", `init: setActiveOrganization failed: ${formatError(err)}`);
         p3.log.error(err instanceof Error ? err.message : String(err));
         p3.outro("Aborted.");
         process.exit(1);
@@ -1163,6 +1401,7 @@ async function runInit(args = []) {
           await client.setActiveOrganization(pickedId);
         }
       } catch (err) {
+        appendLog("error", `init: setActiveOrganization failed: ${formatError(err)}`);
         p3.log.error(err instanceof Error ? err.message : String(err));
         p3.outro("Aborted.");
         process.exit(1);
@@ -1203,6 +1442,10 @@ async function runInit(args = []) {
       process.exit(1);
     }
     workspace = picked;
+    appendLog(
+      "info",
+      `init: workspace selected (slug=${workspace.slug}, id=${workspace.id}, orgId=${pickedId})`
+    );
   }
   const types = await withSpinner(
     "Loading contribution types...",
@@ -1253,6 +1496,10 @@ async function runInit(args = []) {
     p3.outro("Aborted.");
     process.exit(1);
   }
+  appendLog(
+    "info",
+    `init: contribution type selected (slug=${type.slug}, name=${type.name})`
+  );
   const pickedOrg = orgs.find((o) => o.id === activeOrgId);
   await upsertProject(repoRoot, {
     apiBaseUrl,
@@ -1265,6 +1512,7 @@ async function runInit(args = []) {
     contributionTypeName: type.name,
     autoSubmit: true
   });
+  appendLog("info", `init: project config saved (repoRoot=${repoRoot})`);
   p3.log.success(`Saved config for ${repoRoot}`);
   await saveIdentity({
     apiBaseUrl,
@@ -1276,10 +1524,19 @@ async function runInit(args = []) {
   try {
     const hookResults = await installDetectedHooks(repoRoot);
     if (hookResults.length === 0) {
+      appendLog(
+        "warn",
+        "init: no supported tools detected, hooks not installed"
+      );
       p3.log.warn(
-        "No supported tools detected (.claude/, .cursor/, .codex/). Hook not installed."
+        "No supported tools detected (Claude Code, Cursor, Codex, opencode, GitHub Copilot Chat). Hook not installed."
       );
     } else {
+      const tools = hookResults.map((r) => `${r.tool}${r.alreadyPresent ? "(existing)" : ""}`).join(",");
+      appendLog(
+        "info",
+        `init: hooks installed (count=${hookResults.length}, tools=${tools})`
+      );
       for (const r of hookResults) {
         if (r.alreadyPresent) {
           p3.log.info(`${r.label} hook already present`);
@@ -1291,9 +1548,17 @@ async function runInit(args = []) {
         try {
           const changed = await ensureCodexHooksEnabled();
           if (changed) {
+            appendLog(
+              "info",
+              "init: enabled codex_hooks in ~/.codex/config.toml"
+            );
             p3.log.success("Enabled codex_hooks in ~/.codex/config.toml");
           }
         } catch (err) {
+          appendLog(
+            "warn",
+            `init: could not enable codex_hooks: ${formatError(err)}`
+          );
           p3.log.warn(
             `Could not enable codex_hooks in config.toml: ${err instanceof Error ? err.message : String(err)}`
           );
@@ -1301,12 +1566,17 @@ async function runInit(args = []) {
       }
     }
   } catch (err) {
+    appendLog("error", `init: failed to install hooks: ${formatError(err)}`);
     p3.log.error(
       `Failed to install hooks: ${err instanceof Error ? err.message : String(err)}`
     );
     p3.outro("Partially configured. Re-run after fixing the error.");
     process.exit(1);
   }
+  appendLog(
+    "info",
+    `init: completed (workspace=${workspace.slug}, contributionType=${type.slug})`
+  );
   p3.outro(
     `Done. Your next coding session in this repo will upload automatically to ${workspace.name}.`
   );
@@ -1347,6 +1617,7 @@ function resolveDefaultApiUrl2() {
 async function runLogin(_args = []) {
   const apiBaseUrl = resolveDefaultApiUrl2();
   header("login");
+  appendLog("info", `login: started (apiBaseUrl=${apiBaseUrl})`);
   const saved = await loadIdentity(apiBaseUrl);
   if (saved) {
     if (IS_TTY) {
@@ -1377,6 +1648,10 @@ async function runLogin(_args = []) {
       process.stdout.write("\r\x1B[K");
     }
     if (verified) {
+      appendLog(
+        "info",
+        `login: reused saved login (email=${verified.email})`
+      );
       row(CHECK, "Signed in", cyan(verified.email));
       const fresh = probe.getSessionCookie();
       if (fresh) {
@@ -1395,10 +1670,15 @@ async function runLogin(_args = []) {
       return;
     }
     if (expired) {
+      appendLog("info", "login: saved login expired, falling through");
       row(CROSS, "Signed in", dim("expired \u2014 please sign in again"));
       println();
       await clearIdentity(apiBaseUrl);
     } else if (verifyError) {
+      appendLog(
+        "warn",
+        `login: could not verify saved login: ${formatError(verifyError)}`
+      );
       row(CROSS, "Signed in", dim("could not verify saved login"));
       println(`  ${dim(verifyError.message)}`);
       println();
@@ -1424,9 +1704,11 @@ async function runLogin(_args = []) {
     }
     method = selected;
   }
+  appendLog("info", `login: auth method selected (${method})`);
   if (method === "web") {
     const result = await webAuth(apiBaseUrl);
     if (!result) {
+      appendLog("error", "login: web authentication failed");
       p4.log.error("Web authentication failed.");
       p4.outro("Aborted.");
       process.exit(1);
@@ -1438,9 +1720,10 @@ async function runLogin(_args = []) {
       userId: result.userId,
       savedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
+    appendLog("info", `login: completed via web auth (email=${result.email})`);
     println();
     row(CHECK, "Signed in", cyan(result.email));
-    footer("Run `npx hillclimb init` in a repo to wire up auto-upload.");
+    footer("Run `npx hillclimb` in a repo to wire up auto-upload.");
     return;
   }
   const email = await requireText("Email");
@@ -1464,6 +1747,7 @@ async function runLogin(_args = []) {
   );
   const cookie = client.getSessionCookie();
   if (!cookie) {
+    appendLog("error", "login: session cookie missing after sign-in");
     p4.log.error("Session cookie was lost during sign-in.");
     p4.outro("Aborted.");
     process.exit(1);
@@ -1475,9 +1759,13 @@ async function runLogin(_args = []) {
     userId: bootstrap.session.userId,
     savedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
+  appendLog(
+    "info",
+    `login: completed via email/password (email=${bootstrap.session.email})`
+  );
   println();
   row(CHECK, "Signed in", cyan(bootstrap.session.email));
-  footer("Run `npx hillclimb init` in a repo to wire up auto-upload.");
+  footer("Run `npx hillclimb` in a repo to wire up auto-upload.");
 }
 
 // src/commands/logout.ts
@@ -1509,39 +1797,12 @@ async function runLogout(args = []) {
   );
   footer(
     "Per-repo upload hooks still active.",
-    "Re-run `npx hillclimb init` to re-authenticate a repo."
+    "Re-run `npx hillclimb` to re-authenticate a repo."
   );
 }
 
 // src/commands/status.ts
 import path6 from "path";
-
-// src/platform/log.ts
-import fs4 from "fs";
-import path5 from "path";
-function today() {
-  const d = /* @__PURE__ */ new Date();
-  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
-}
-function logsDir() {
-  return path5.join(configDir(), "logs");
-}
-function todayLogPath() {
-  return path5.join(logsDir(), `${today()}.log`);
-}
-function appendLog(level, message) {
-  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${message}
-`;
-  try {
-    fs4.mkdirSync(logsDir(), { recursive: true, mode: 448 });
-    fs4.appendFileSync(todayLogPath(), line);
-  } catch {
-    process.stderr.write(`hillclimb: ${level}: ${message}
-`);
-  }
-}
-
-// src/commands/status.ts
 async function runStatus(args = []) {
   const debug = args.includes("--debug");
   header("status");
@@ -1555,7 +1816,7 @@ async function runStatus(args = []) {
       return;
     }
     row(CROSS, "Repo", `${bold(repo.name)} ${dim("(not configured)")}`);
-    footer(`Run \`npx hillclimb init\` in ${repo.name} to connect it.`);
+    footer(`Run \`npx hillclimb\` in ${repo.name} to connect it.`);
     return;
   }
   const { repoRoot, config } = match;
@@ -1617,11 +1878,11 @@ async function runStatus(args = []) {
     row(CROSS, "Auto-upload", dim("error checking hooks"));
   }
   if (loginError === "expired") {
-    footer("Run `npx hillclimb init` to sign in again.");
+    footer("Run `npx hillclimb` to sign in again.");
   } else if (loginError === "unreachable") {
     footer(`Couldn't reach ${config.apiBaseUrl}. Check your connection.`);
   } else if (!anyHookInstalled) {
-    footer("Run `npx hillclimb init` to install the upload hook.");
+    footer("Run `npx hillclimb` to install the upload hook.");
   } else {
     footer("All set.");
   }
@@ -11464,6 +11725,9 @@ function formatTitleTimestamp(date) {
   const pad = (n) => String(n).padStart(2, "0");
   return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
 }
+function lineHasAssistant(line) {
+  return line.includes('"type":"assistant"') || line.includes('"role":"assistant"') || line.includes('"type":"assistant.');
+}
 async function hasAssistantMessage(transcriptPath) {
   const stream = fs8.createReadStream(transcriptPath, { encoding: "utf-8" });
   let buffer = "";
@@ -11474,15 +11738,14 @@ async function hasAssistantMessage(transcriptPath) {
       while (newlineIdx !== -1) {
         const line = buffer.slice(0, newlineIdx);
         buffer = buffer.slice(newlineIdx + 1);
-        if (line.includes('"type":"assistant"') || line.includes('"role":"assistant"')) {
+        if (lineHasAssistant(line)) {
           stream.destroy();
           return true;
         }
         newlineIdx = buffer.indexOf("\n");
       }
     }
-    if (buffer.includes('"type":"assistant"') || buffer.includes('"role":"assistant"'))
-      return true;
+    if (lineHasAssistant(buffer)) return true;
   } catch {
     return true;
   }
@@ -11546,7 +11809,7 @@ async function runUploadInner(payload) {
   if (!match) {
     appendLog(
       "warn",
-      `Skipping session ${sessionId}: no hillclimb config for cwd ${cwd}. Run \`npx hillclimb init\` in the repo.`
+      `Skipping session ${sessionId}: no hillclimb config for cwd ${cwd}. Run \`npx hillclimb\` in the repo.`
     );
     return;
   }
@@ -11600,7 +11863,13 @@ async function uploadSession(args) {
   }
   const client = new PlatformClient(config.apiBaseUrl, identity.sessionCookie);
   const shortId = sessionId.slice(0, 12);
-  const toolLabels = { cursor: "Cursor", codex: "Codex", claude: "Claude", opencode: "opencode" };
+  const toolLabels = {
+    cursor: "Cursor",
+    codex: "Codex",
+    claude: "Claude",
+    "copilot-chat": "GitHub Copilot Chat",
+    opencode: "opencode"
+  };
   const toolLabel = toolLabels[sourceTool] ?? "Claude";
   const title = `${toolLabel} session ${shortId} \u2014 ${formatTitleTimestamp(now)}`;
   const body = `Session ID: ${sessionId}
@@ -11630,7 +11899,7 @@ Uploaded: ${now.toISOString()}`;
     if (err instanceof PlatformError && err.status === 401) {
       appendLog(
         "error",
-        `Session ${sessionId} upload failed: authentication expired. Re-run \`npx hillclimb init\` in ${repoRoot}.`
+        `Session ${sessionId} upload failed: authentication expired. Re-run \`npx hillclimb\` in ${repoRoot}.`
       );
       return;
     }
@@ -11641,6 +11910,15 @@ Uploaded: ${now.toISOString()}`;
   }
 }
 var WORKER_ENV_FLAG = "HILLCLIMB_UPLOAD_WORKER";
+var TOOL_ENV_FLAG = "HILLCLIMB_UPLOAD_TOOL";
+function parseToolArg(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--tool=")) return a.slice("--tool=".length);
+    if (a === "--tool" && i + 1 < argv.length) return argv[i + 1];
+  }
+  return null;
+}
 async function runUpload() {
   if (process.env[WORKER_ENV_FLAG] === "1") {
     await runUploadWorker();
@@ -11669,11 +11947,17 @@ async function runUpload() {
     appendLog("error", "Cannot detach worker: process.argv[1] is empty");
     return;
   }
+  const toolArg = parseToolArg(process.argv.slice(2));
+  const workerEnv = {
+    ...process.env,
+    [WORKER_ENV_FLAG]: "1"
+  };
+  if (toolArg) workerEnv[TOOL_ENV_FLAG] = toolArg;
   try {
     const child = spawn2(process.execPath, [entrypoint, "upload"], {
       detached: true,
       stdio: ["pipe", "ignore", "ignore"],
-      env: { ...process.env, [WORKER_ENV_FLAG]: "1" }
+      env: workerEnv
     });
     child.on("error", (err) => {
       appendLog("error", `Failed to spawn worker: ${err.message}`);
@@ -11719,6 +12003,8 @@ async function runUploadWorker() {
     );
     return;
   }
+  const toolOverride = process.env[TOOL_ENV_FLAG];
+  if (toolOverride) payload.tool = toolOverride;
   try {
     await runUploadInner(payload);
   } catch (err) {
@@ -11731,6 +12017,7 @@ async function runUploadWorker() {
 
 // src/git-traces/index.ts
 import { spawn as spawn3 } from "child_process";
+import crypto2 from "crypto";
 
 // src/git-traces/handlers.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -11741,23 +12028,74 @@ import fs9 from "fs";
 import os6 from "os";
 import path12 from "path";
 import { gzipSync } from "zlib";
-var EXEC_OPTS = { timeout: 3e4, maxBuffer: 50 * 1024 * 1024 };
+var GIT_COMMAND_TIMEOUT_MS = 12e4;
+var EXEC_OPTS = {
+  timeout: GIT_COMMAND_TIMEOUT_MS,
+  maxBuffer: 50 * 1024 * 1024
+};
+var MAX_ERROR_OUTPUT_CHARS = 2e3;
 var MAX_UNTRACKED_FILE_BYTES = 10 * 1024 * 1024;
 var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+function quoteGitArg(arg) {
+  if (/^[A-Za-z0-9_./:=@%+,-]+$/.test(arg)) return arg;
+  return JSON.stringify(arg);
+}
+function formatGitCommand(args) {
+  return ["git", ...args.map(quoteGitArg)].join(" ");
+}
+function outputToString(output) {
+  if (Buffer.isBuffer(output)) return output.toString("utf-8").trim();
+  if (typeof output === "string") return output.trim();
+  return null;
+}
+function truncateOutput(output) {
+  if (output.length <= MAX_ERROR_OUTPUT_CHARS) return output;
+  return `${output.slice(0, MAX_ERROR_OUTPUT_CHARS)}...`;
+}
+function formatGitFailure(command, failure, err) {
+  const details = [];
+  if (typeof failure.status === "number")
+    details.push(`exit=${failure.status}`);
+  if (failure.signal) details.push(`signal=${failure.signal}`);
+  const stderr = outputToString(failure.stderr);
+  if (stderr) details.push(`stderr=${truncateOutput(stderr)}`);
+  const stdout = outputToString(failure.stdout);
+  if (!stderr && stdout) details.push(`stdout=${truncateOutput(stdout)}`);
+  if (details.length === 0 && err instanceof Error && err.message) {
+    details.push(err.message);
+  }
+  return `${command} failed${details.length ? ` (${details.join("; ")})` : ""}`;
+}
+function createGitError(args, err) {
+  const failure = err;
+  const command = formatGitCommand(args);
+  const isTimeout = failure.code === "ETIMEDOUT";
+  const message = isTimeout ? `${command} timed out after ${GIT_COMMAND_TIMEOUT_MS}ms` : formatGitFailure(command, failure, err);
+  const wrapped = new Error(message);
+  wrapped.isGitTimeout = isTimeout;
+  return wrapped;
+}
+function isGitTimeoutError(err) {
+  return err instanceof Error && err.isGitTimeout === true;
+}
+function gitBuffer(repoRoot, args, options = {}) {
+  try {
+    return execFileSync("git", args, {
+      cwd: repoRoot,
+      ...options.env ? { env: options.env } : {},
+      ...options.input !== void 0 ? { input: options.input } : {},
+      stdio: ["pipe", "pipe", "pipe"],
+      ...EXEC_OPTS
+    });
+  } catch (err) {
+    throw createGitError(args, err);
+  }
+}
 function git(repoRoot, args) {
-  return execFileSync("git", args, {
-    cwd: repoRoot,
-    stdio: ["pipe", "pipe", "pipe"],
-    ...EXEC_OPTS
-  }).toString("utf-8").trim();
+  return gitBuffer(repoRoot, args).toString("utf-8").trim();
 }
 function gitWithEnv(repoRoot, args, env) {
-  return execFileSync("git", args, {
-    cwd: repoRoot,
-    env,
-    stdio: ["pipe", "pipe", "pipe"],
-    ...EXEC_OPTS
-  }).toString("utf-8").trim();
+  return gitBuffer(repoRoot, args, { env }).toString("utf-8").trim();
 }
 function isGitRepo(dir) {
   try {
@@ -11771,11 +12109,13 @@ function captureBaselineSha(repoRoot) {
   try {
     const sha = git(repoRoot, ["stash", "create"]);
     if (sha) return sha;
-  } catch {
+  } catch (err) {
+    if (isGitTimeoutError(err)) throw err;
   }
   try {
     return git(repoRoot, ["rev-parse", "HEAD"]);
-  } catch {
+  } catch (err) {
+    if (isGitTimeoutError(err)) throw err;
     const tree = git(repoRoot, ["write-tree"]);
     return git(repoRoot, ["commit-tree", tree, "-m", "empty baseline"]);
   }
@@ -11793,7 +12133,8 @@ function captureSnapshotSha(repoRoot) {
   try {
     const sha = git(repoRoot, ["stash", "create"]);
     if (sha) return sha;
-  } catch {
+  } catch (err) {
+    if (isGitTimeoutError(err)) throw err;
   }
   return git(repoRoot, ["rev-parse", "HEAD"]);
 }
@@ -11828,12 +12169,9 @@ function buildUntrackedTree(repoRoot) {
   );
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
   try {
-    execFileSync("git", ["update-index", "--add", "-z", "--stdin"], {
-      cwd: repoRoot,
-      env,
-      input: kept.join("\0") + "\0",
-      stdio: ["pipe", "pipe", "pipe"],
-      ...EXEC_OPTS
+    gitBuffer(repoRoot, ["update-index", "--add", "-z", "--stdin"], {
+      input: `${kept.join("\0")}\0`,
+      env
     });
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
@@ -11856,10 +12194,12 @@ function buildSnapshotTree(repoRoot, stashSha) {
   const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
   try {
     gitWithEnv(repoRoot, ["read-tree", trackedTree], env);
-    const untrackedList = execFileSync(
-      "git",
+    const untrackedList = gitBuffer(
+      repoRoot,
       ["ls-tree", "-r", untrackedTree],
-      { cwd: repoRoot, env, stdio: ["pipe", "pipe", "pipe"], ...EXEC_OPTS }
+      {
+        env
+      }
     ).toString("utf-8");
     const indexInfo = untrackedList.split("\n").filter(Boolean).map((line) => {
       const [meta, filePath] = line.split("	");
@@ -11867,12 +12207,9 @@ function buildSnapshotTree(repoRoot, stashSha) {
       return `${mode} ${sha}	${filePath}`;
     }).join("\n");
     if (indexInfo) {
-      execFileSync("git", ["update-index", "--index-info"], {
-        cwd: repoRoot,
-        env,
+      gitBuffer(repoRoot, ["update-index", "--index-info"], {
         input: indexInfo,
-        stdio: ["pipe", "pipe", "pipe"],
-        ...EXEC_OPTS
+        env
       });
     }
     return gitWithEnv(repoRoot, ["write-tree"], env);
@@ -11909,15 +12246,12 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
 }
 function createTreeDiffPatchGz(repoRoot, fromTreeSha, toTreeSha) {
   if (fromTreeSha === toTreeSha) return null;
-  const diff = execFileSync(
-    "git",
-    ["diff", "--binary", fromTreeSha, toTreeSha],
-    {
-      cwd: repoRoot,
-      stdio: ["pipe", "pipe", "pipe"],
-      ...EXEC_OPTS
-    }
-  );
+  const diff = gitBuffer(repoRoot, [
+    "diff",
+    "--binary",
+    fromTreeSha,
+    toTreeSha
+  ]);
   if (diff.length === 0) return null;
   return Buffer.from(gzipSync(diff));
 }
@@ -11976,7 +12310,11 @@ function buildBaselineMetadata(repoRoot, sessionId, tool, baselineSha, cliVersio
 function enumerateCommits(repoRoot, fromSha, toSha) {
   let shas;
   try {
-    const out = git(repoRoot, ["rev-list", "--reverse", `${fromSha}..${toSha}`]);
+    const out = git(repoRoot, [
+      "rev-list",
+      "--reverse",
+      `${fromSha}..${toSha}`
+    ]);
     if (!out) return [];
     shas = out.split("\n").filter(Boolean);
   } catch (err) {
@@ -12028,12 +12366,7 @@ function parseCommitFiles(repoRoot, sha) {
   let nameStatus = "";
   let numstat = "";
   try {
-    nameStatus = git(repoRoot, [
-      "show",
-      "--name-status",
-      "--format=",
-      sha
-    ]);
+    nameStatus = git(repoRoot, ["show", "--name-status", "--format=", sha]);
     numstat = git(repoRoot, ["show", "--numstat", "--format=", sha]);
   } catch {
     return [];
@@ -12058,9 +12391,9 @@ function parseCommitFiles(repoRoot, sha) {
         oldPath
       });
     } else {
-      const path19 = parts[parts.length - 1];
-      indexByPath.set(path19, files.length);
-      files.push({ path: path19, status, additions: 0, deletions: 0 });
+      const path20 = parts[parts.length - 1];
+      indexByPath.set(path20, files.length);
+      files.push({ path: path20, status, additions: 0, deletions: 0 });
     }
   }
   for (const line of numstat.split("\n")) {
@@ -12081,7 +12414,13 @@ function parseCommitFiles(repoRoot, sha) {
 function safeGit(repoRoot, args) {
   try {
     return git(repoRoot, args);
-  } catch {
+  } catch (err) {
+    if (isGitTimeoutError(err)) {
+      appendLog(
+        "warn",
+        `git-traces: optional metadata command skipped: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
     return null;
   }
 }
@@ -12188,6 +12527,7 @@ var TOOL_LABELS = {
   cursor: "Cursor",
   codex: "Codex",
   claude: "Claude",
+  "copilot-chat": "GitHub Copilot Chat",
   opencode: "opencode"
 };
 function resolveCwd(payload) {
@@ -12235,7 +12575,10 @@ async function uploadFile(client, contributionId, filename, mimeType, buffer) {
     presigned.headers,
     buffer
   );
-  appendLog("info", `git-traces: uploaded ${filename} (${buffer.byteLength} bytes)`);
+  appendLog(
+    "info",
+    `git-traces: uploaded ${filename} (${buffer.byteLength} bytes)`
+  );
 }
 function pinEpochBaseline(repoRoot, sessionId, epoch) {
   const baselineSha = captureBaselineSha(repoRoot);
@@ -12246,11 +12589,9 @@ function pinEpochBaseline(repoRoot, sessionId, epoch) {
   );
   return { baselineSha, headSha: captureHeadSha(repoRoot) };
 }
-async function uploadEpochBaseline(params) {
+function buildEpochBaselineArtifacts(params) {
   const {
     repoRoot,
-    client,
-    contributionId,
     sessionId,
     tool,
     epoch,
@@ -12260,50 +12601,63 @@ async function uploadEpochBaseline(params) {
     startedAt
   } = params;
   const prefix = epochPrefix(epoch);
-  const metadata = buildBaselineMetadata(
-    repoRoot,
-    sessionId,
-    tool,
-    baselineSha,
-    CLI_VERSION,
-    epoch,
-    prevHeadSha,
-    transitionKind,
-    startedAt
-  );
-  let baselineTreeSha;
-  let bundleBuffer;
   try {
-    baselineTreeSha = buildSnapshotTree(repoRoot, baselineSha);
-    bundleBuffer = createBundleFromTree(
+    const metadata = buildBaselineMetadata(
+      repoRoot,
+      sessionId,
+      tool,
+      baselineSha,
+      CLI_VERSION,
+      epoch,
+      prevHeadSha,
+      transitionKind,
+      startedAt
+    );
+    const baselineTreeSha = buildSnapshotTree(repoRoot, baselineSha);
+    const bundleBuffer = createBundleFromTree(
       repoRoot,
       baselineTreeSha,
       `${sessionId}-${prefix}`,
       `baseline ${prefix}`
     );
+    const metadataBuffer = Buffer.from(JSON.stringify(metadata, null, 2));
+    return { baselineTreeSha, metadataBuffer, bundleBuffer };
   } catch (err) {
     appendLog(
       "error",
-      `git-traces: failed to create baseline bundle for ${prefix}: ${err instanceof Error ? err.message : String(err)}`
+      `git-traces: failed to build baseline artifacts for ${prefix}: ${formatError(err)}`
     );
     return null;
   }
-  const metadataBuffer = Buffer.from(JSON.stringify(metadata, null, 2));
+}
+async function uploadEpochBaselineArtifacts(params) {
+  const { client, contributionId, epoch, artifacts } = params;
+  const prefix = epochPrefix(epoch);
   await uploadFile(
     client,
     contributionId,
     `${prefix}-baseline.json`,
     "application/json",
-    metadataBuffer
+    artifacts.metadataBuffer
   );
   await uploadFile(
     client,
     contributionId,
     `${prefix}-baseline.bundle`,
     "application/x-git-bundle",
-    bundleBuffer
+    artifacts.bundleBuffer
   );
-  return { baselineTreeSha };
+}
+async function uploadEpochBaseline(params) {
+  const artifacts = buildEpochBaselineArtifacts(params);
+  if (!artifacts) return null;
+  await uploadEpochBaselineArtifacts({
+    client: params.client,
+    contributionId: params.contributionId,
+    epoch: params.epoch,
+    artifacts
+  });
+  return { baselineTreeSha: artifacts.baselineTreeSha };
 }
 async function openEpoch(params) {
   const { baselineSha, headSha } = pinEpochBaseline(
@@ -12318,7 +12672,10 @@ async function openEpoch(params) {
 async function initializeSession(cwd, tool, sessionId) {
   const project = await findProjectForCwd(cwd);
   if (!project) {
-    appendLog("warn", "git-traces: no hillclimb project config found, skipping");
+    appendLog(
+      "warn",
+      "git-traces: no hillclimb project config found, skipping"
+    );
     return null;
   }
   const { baselineSha, headSha } = pinEpochBaseline(cwd, sessionId, 1);
@@ -12398,6 +12755,17 @@ async function handleStop(payload, tool) {
       identity.sessionCookie
     );
     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;
       const toolLabel = TOOL_LABELS[tool] ?? "Claude";
       const now = /* @__PURE__ */ new Date();
       const shortId = state.sessionId.slice(0, 12);
@@ -12412,23 +12780,16 @@ Repo: ${cwd}
 Uploaded: ${now.toISOString()}`
         }
       );
-      await client.submitContribution(contribution.id);
-      const uploaded = await uploadEpochBaseline({
-        repoRoot: cwd,
+      await uploadEpochBaselineArtifacts({
         client,
         contributionId: contribution.id,
-        sessionId: state.sessionId,
-        tool,
         epoch: 1,
-        baselineSha: state.baselineSha,
-        prevHeadSha: null,
-        transitionKind: "initial",
-        startedAt: state.startedAt
+        artifacts
       });
-      if (!uploaded) return;
+      await client.submitContribution(contribution.id);
       state.contributionId = contribution.id;
-      state.baselineTreeSha = uploaded.baselineTreeSha;
-      state.lastSnapshotTreeSha = uploaded.baselineTreeSha;
+      state.baselineTreeSha = artifacts.baselineTreeSha;
+      state.lastSnapshotTreeSha = artifacts.baselineTreeSha;
       await writeSessionState(state, tool);
       appendLog(
         "info",
@@ -12542,9 +12903,19 @@ async function handleSessionEnd(payload, tool) {
 
 // src/git-traces/index.ts
 var WORKER_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_WORKER";
-var TOOL_ENV_FLAG = "HILLCLIMB_GIT_TRACES_TOOL";
-var KNOWN_TOOLS = /* @__PURE__ */ new Set(["claude", "codex", "cursor", "opencode"]);
-function parseToolArg(argv) {
+var TOOL_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_TOOL";
+var FLOW_ID_ENV = "HILLCLIMB_GIT_TRACES_FLOW";
+function newFlowId() {
+  return crypto2.randomBytes(3).toString("hex");
+}
+var KNOWN_TOOLS = /* @__PURE__ */ new Set([
+  "claude",
+  "codex",
+  "copilot-chat",
+  "cursor",
+  "opencode"
+]);
+function parseToolArg2(argv) {
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a.startsWith("--tool=")) return a.slice("--tool=".length);
@@ -12565,7 +12936,9 @@ async function runGitTraces() {
     await runGitTracesWorker();
     return;
   }
-  const toolArg = parseToolArg(process.argv.slice(2));
+  const flowId = newFlowId();
+  setLogPrefix(`[${flowId}]`);
+  const toolArg = parseToolArg2(process.argv.slice(2));
   appendLog(
     "info",
     `git-traces hook invoked (pid ${process.pid}, tool=${toolArg ?? "<none>"})`
@@ -12581,10 +12954,7 @@ async function runGitTraces() {
   try {
     raw = await readStdin2();
   } catch (err) {
-    appendLog(
-      "error",
-      `git-traces: failed to read stdin: ${err instanceof Error ? err.message : String(err)}`
-    );
+    appendLog("error", `git-traces: failed to read stdin: ${formatError(err)}`);
     return;
   }
   if (!raw.trim()) {
@@ -12606,7 +12976,8 @@ async function runGitTraces() {
         env: {
           ...process.env,
           [WORKER_ENV_FLAG2]: "1",
-          [TOOL_ENV_FLAG]: toolArg
+          [TOOL_ENV_FLAG2]: toolArg,
+          [FLOW_ID_ENV]: flowId
         }
       }
     );
@@ -12623,12 +12994,13 @@ async function runGitTraces() {
   } catch (err) {
     appendLog(
       "error",
-      `git-traces: failed to spawn worker: ${err instanceof Error ? err.message : String(err)}`
+      `git-traces: failed to spawn worker: ${formatError(err)}`
     );
   }
 }
 async function runGitTracesWorker() {
-  const tool = process.env[TOOL_ENV_FLAG] ?? parseToolArg(process.argv.slice(2)) ?? null;
+  setLogPrefix(`[${process.env[FLOW_ID_ENV] ?? newFlowId()}]`);
+  const tool = process.env[TOOL_ENV_FLAG2] ?? parseToolArg2(process.argv.slice(2)) ?? null;
   appendLog(
     "info",
     `git-traces worker started (pid ${process.pid}, tool=${tool ?? "<none>"})`
@@ -12646,7 +13018,7 @@ async function runGitTracesWorker() {
   } catch (err) {
     appendLog(
       "error",
-      `git-traces worker: failed to read stdin: ${err instanceof Error ? err.message : String(err)}`
+      `git-traces worker: failed to read stdin: ${formatError(err)}`
     );
     return;
   }
@@ -12660,7 +13032,7 @@ async function runGitTracesWorker() {
   } catch (err) {
     appendLog(
       "error",
-      `git-traces worker: failed to parse payload: ${err instanceof Error ? err.message : String(err)}`
+      `git-traces worker: failed to parse payload: ${formatError(err)}`
     );
     return;
   }
@@ -12699,9 +13071,12 @@ async function runGitTracesWorker() {
         appendLog("warn", `git-traces worker: unknown event ${event}`);
     }
   } catch (err) {
+    const detail = formatError(err);
+    const stack = err instanceof Error ? err.stack : void 0;
     appendLog(
       "error",
-      `git-traces worker: unexpected error: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
+      `git-traces worker: unexpected error: ${detail}${stack ? `
+${stack}` : ""}`
     );
   }
 }
@@ -13202,8 +13577,106 @@ var CodexSource = class {
   }
 };
 
+// src/sources/copilotChat.ts
+import fs15 from "fs";
+import os11 from "os";
+import path18 from "path";
+import { fileURLToPath } from "url";
+function vsCodeUserDirs() {
+  const home = os11.homedir();
+  const dirs = [
+    path18.join(home, "Library", "Application Support", "Code", "User"),
+    path18.join(home, ".config", "Code", "User")
+  ];
+  if (process.env.APPDATA) {
+    dirs.push(path18.join(process.env.APPDATA, "Code", "User"));
+  }
+  return dirs;
+}
+function uriToFsPath(uri) {
+  if (!uri.startsWith("file://")) return null;
+  try {
+    return fileURLToPath(uri);
+  } catch {
+    return null;
+  }
+}
+async function readWorkspaceFolder(workspaceJsonPath) {
+  let raw;
+  try {
+    raw = await fs15.promises.readFile(workspaceJsonPath, "utf-8");
+  } catch {
+    return null;
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!data || typeof data !== "object") return null;
+  const obj = data;
+  if (typeof obj.folder === "string") {
+    return uriToFsPath(obj.folder) ?? obj.folder;
+  }
+  return null;
+}
+var CopilotChatSource = class {
+  name = "copilot-chat";
+  async scan() {
+    const results = [];
+    for (const userDir of vsCodeUserDirs()) {
+      const workspaceStorage = path18.join(userDir, "workspaceStorage");
+      let hashDirs;
+      try {
+        hashDirs = await fs15.promises.readdir(workspaceStorage, {
+          withFileTypes: true
+        });
+      } catch {
+        continue;
+      }
+      for (const hash of hashDirs) {
+        if (!hash.isDirectory()) continue;
+        const wsRoot = path18.join(workspaceStorage, hash.name);
+        const transcriptsDir = path18.join(
+          wsRoot,
+          "GitHub.copilot-chat",
+          "transcripts"
+        );
+        let transcriptEntries;
+        try {
+          transcriptEntries = await fs15.promises.readdir(transcriptsDir, {
+            withFileTypes: true
+          });
+        } catch {
+          continue;
+        }
+        const repoPath = await readWorkspaceFolder(
+          path18.join(wsRoot, "workspace.json")
+        );
+        if (!repoPath) continue;
+        for (const entry of transcriptEntries) {
+          if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+          const sessionId = entry.name.slice(0, -".jsonl".length);
+          results.push({
+            sourceName: this.name,
+            absolutePath: path18.join(transcriptsDir, entry.name),
+            repoPath,
+            metadata: { sessionId }
+          });
+        }
+      }
+    }
+    return results;
+  }
+};
+
 // src/sources/index.ts
-var sources = [new ClaudeSource(), new CodexSource()];
+var sources = [
+  new ClaudeSource(),
+  new CodexSource(),
+  new CopilotChatSource()
+];
 
 // src/cli.ts
 function reportRedactionStats(noun, stats) {
@@ -13227,7 +13700,7 @@ function reportRedactionStats(noun, stats) {
 async function filterByTimeRange(group, range) {
   const results = await Promise.all(
     group.files.map(
-      (f) => fs15.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
+      (f) => fs16.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
     )
   );
   const filtered = [];
@@ -13254,10 +13727,10 @@ async function runInteractive() {
   s.start(`Scanning ${source.name} logs...`);
   const allFiles = await source.scan();
   const allGroups = await mergeByRepo(allFiles);
-  const repoRoot = path18.resolve(repo.root);
+  const repoRoot = path19.resolve(repo.root);
   const matching = allGroups.filter((g) => {
-    const resolved = path18.resolve(g.repoPath);
-    return resolved === repoRoot || resolved.startsWith(repoRoot + path18.sep);
+    const resolved = path19.resolve(g.repoPath);
+    return resolved === repoRoot || resolved.startsWith(repoRoot + path19.sep);
   });
   if (matching.length === 0) {
     s.stop(`No ${source.name} logs found for ${repo.name}.`);
@@ -13288,7 +13761,7 @@ async function runInteractive() {
     }
   }
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path18.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path19.join(repoRoot, n));
   const additionalFiles = await promptSecretFiles(envFileNames);
   const secretResult = await collectSecrets(
     repoRoot,
@@ -13332,11 +13805,14 @@ async function main() {
   const [, , subcommand, ...rest] = process.argv;
   switch (subcommand) {
     case void 0:
-      await runInteractive();
+      await runInit([]);
       return;
     case "init":
       await runInit(rest);
       return;
+    case "export":
+      await runInteractive();
+      return;
     case "login":
       await runLogin(rest);
       return;
@@ -13356,11 +13832,15 @@ async function main() {
     case "-h":
     case "help": {
       process.stdout.write(
-        "Usage: npx hillclimb [subcommand]\n\nSubcommands:\n  (none)   Interactive export flow (manual use)\n  login    Sign in and save the credential for reuse across repos\n  logout   Clear the saved sign-in (pass --url <api> to scope to one instance)\n  init     Configure this repo for automatic upload (--login forces fresh sign-in)\n  status   Show whether you're signed in and this repo is connected (pass --debug for details)\n  upload   Hook entry point \u2014 reads JSON payload from stdin and uploads one session\n  help     Show this message\n"
+        "Usage: npx hillclimb [subcommand]\n\nSubcommands:\n  (none)   Configure this repo for automatic upload\n  init     Configure this repo for automatic upload (--login forces fresh sign-in)\n  export   Interactive export flow (manual use)\n  login    Sign in and save the credential for reuse across repos\n  logout   Clear the saved sign-in (pass --url <api> to scope to one instance)\n  status   Show whether you're signed in and this repo is connected (pass --debug for details)\n  upload   Hook entry point \u2014 reads JSON payload from stdin and uploads one session\n  help     Show this message\n"
       );
       return;
     }
     default:
+      if (subcommand === "--login" || subcommand === "--workspace" || subcommand.startsWith("--workspace=")) {
+        await runInit([subcommand, ...rest]);
+        return;
+      }
       process.stderr.write(
         `Unknown subcommand: ${subcommand}${rest.length > 0 ? ` ${rest.join(" ")}` : ""}
 `