hillclimb 0.1.3 → 0.1.4

package/README.md

@@ -5,7 +5,7 @@ Extract AI coding tool sessions (Claude Code, Cursor, Codex, opencode) and uploa
 ## Quickstart
 
 ```sh
-npx hillclimb init
+npx hillclimb
 ```
 
 Run in any git repo. Sessions auto-upload when they end.
@@ -18,7 +18,25 @@ Shows login and hook status for the current repo.
 
 ## Hooks
 
-`hillclimb init` detects which tools you use (`~/.claude`, `~/.cursor`, `~/.codex`, `~/.local/share/opencode`) and installs upload + git-trace hooks for each. You might want to gitignore the respective directories for the tools you use in your repo.
+`hillclimb` detects which tools you use (`~/.claude`, `~/.cursor`, `~/.codex`, `~/.local/share/opencode`) and installs upload + git-trace hooks for each. You might want to gitignore the respective directories for the tools you use in your repo.
+
+To manually export historical logs instead of configuring auto-upload, run:
+
+```sh
+npx hillclimb export
+```
+
+## Logs
+
+Hillclimb writes one log file per day to `~/.hillclimb/logs/YYYY-MM-DD.log`. Timestamps and the daily filename are in Pacific Time, so logs line up with Hillclimb's internal clock regardless of your timezone.
+
+Each hook firing tags every line it writes (parent + worker) with a short correlation ID, e.g. `[a1b2c3]`. To follow one flow across interleaved hook runs:
+
+```sh
+grep '\[a1b2c3\]' ~/.hillclimb/logs/$(TZ=America/Los_Angeles date +%F).log
+```
+
+HTTP calls log method, path, status, and latency. Auth codes and presigned-URL signatures are deliberately omitted.
 
 ## License
 

package/dist/cli.js

@@ -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,7 @@ 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
@@ -462,36 +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 = path4.join(
+  const suffix = path5.join(
     "User",
     "globalStorage",
     "github.copilot-chat"
   );
   const candidates = [
-    path4.join(home, "Library", "Application Support", "Code", suffix),
-    path4.join(home, ".config", "Code", suffix),
-    process.env.APPDATA ? path4.join(process.env.APPDATA, "Code", suffix) : null
+    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 {};
@@ -501,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) {
@@ -613,8 +740,8 @@ function copilotUninstall(settings, eventName, command) {
 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";
@@ -760,19 +887,19 @@ 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;
@@ -900,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"
       );
@@ -926,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];
@@ -982,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...",
@@ -991,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)}`);
@@ -1004,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";
@@ -1019,6 +1153,10 @@ async function webAuth(apiBaseUrl) {
             return data;
           }
         );
+        appendLog(
+          "info",
+          `web-auth: completed (email=${bootstrap.session.email})`
+        );
         return {
           client,
           sessionCookie,
@@ -1027,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;
@@ -1087,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);
@@ -1126,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);
@@ -1193,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(
@@ -1209,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);
@@ -1249,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);
@@ -1289,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...",
@@ -1339,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,
@@ -1351,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,
@@ -1362,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 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`);
@@ -1377,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)}`
           );
@@ -1387,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}.`
   );
@@ -1433,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) {
@@ -1463,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) {
@@ -1481,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();
@@ -1510,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);
@@ -1524,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");
@@ -1550,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);
@@ -1561,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
@@ -1595,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");
@@ -1641,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;
@@ -1703,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.");
   }
@@ -11634,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;
   }
@@ -11724,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;
     }
@@ -11842,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";
@@ -11852,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 {
@@ -11882,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"]);
   }
@@ -11904,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"]);
 }
@@ -11939,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 {
@@ -11967,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("	");
@@ -11978,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);
@@ -12020,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));
 }
@@ -12087,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) {
@@ -12139,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 [];
@@ -12192,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;
   }
 }
@@ -12347,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);
@@ -12358,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,
@@ -12372,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(
@@ -12430,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);
@@ -12510,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);
@@ -12524,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",
@@ -12655,6 +12904,10 @@ async function handleSessionEnd(payload, tool) {
 // src/git-traces/index.ts
 var WORKER_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_WORKER";
 var TOOL_ENV_FLAG2 = "HILLCLIMB_GIT_TRACES_TOOL";
+var FLOW_ID_ENV = "HILLCLIMB_GIT_TRACES_FLOW";
+function newFlowId() {
+  return crypto2.randomBytes(3).toString("hex");
+}
 var KNOWN_TOOLS = /* @__PURE__ */ new Set([
   "claude",
   "codex",
@@ -12683,6 +12936,8 @@ async function runGitTraces() {
     await runGitTracesWorker();
     return;
   }
+  const flowId = newFlowId();
+  setLogPrefix(`[${flowId}]`);
   const toolArg = parseToolArg2(process.argv.slice(2));
   appendLog(
     "info",
@@ -12699,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()) {
@@ -12724,7 +12976,8 @@ async function runGitTraces() {
         env: {
           ...process.env,
           [WORKER_ENV_FLAG2]: "1",
-          [TOOL_ENV_FLAG2]: toolArg
+          [TOOL_ENV_FLAG2]: toolArg,
+          [FLOW_ID_ENV]: flowId
         }
       }
     );
@@ -12741,11 +12994,12 @@ 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() {
+  setLogPrefix(`[${process.env[FLOW_ID_ENV] ?? newFlowId()}]`);
   const tool = process.env[TOOL_ENV_FLAG2] ?? parseToolArg2(process.argv.slice(2)) ?? null;
   appendLog(
     "info",
@@ -12764,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;
   }
@@ -12778,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;
   }
@@ -12817,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}` : ""}`
     );
   }
 }
@@ -13548,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;
@@ -13572,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(" ")}` : ""}
 `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hillclimb",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Extract and export AI coding tool logs grouped by repo",
   "license": "MIT",
   "type": "module",