hillclimb 0.1.8 → 0.1.9

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs16 from "fs";
-import path19 from "path";
+import fs17 from "fs";
+import path20 from "path";
 import * as p6 from "@clack/prompts";
 
 // src/commands/init.ts
@@ -125,16 +125,65 @@ function detectRepoRoot() {
   }
 }
 
-// src/identity.ts
+// src/gitignore.ts
 import fs2 from "fs";
 import path3 from "path";
-var IDENTITY_PATH = path3.join(configDir(), "identity.json");
+function toGitignorePattern(repoRoot, file) {
+  const rel = path3.relative(repoRoot, file);
+  if (!rel || rel.startsWith("..") || path3.isAbsolute(rel)) return null;
+  return `/${rel.split(path3.sep).join("/")}`;
+}
+function normalizePattern(pattern) {
+  return pattern.trim().replace(/\\/g, "/").replace(/^\/+/, "");
+}
+async function ensureGitignored(repoRoot, files) {
+  const gitignorePath = path3.join(repoRoot, ".gitignore");
+  const patterns = [
+    ...new Set(
+      files.map((file) => toGitignorePattern(repoRoot, file)).filter((pattern) => pattern !== null)
+    )
+  ];
+  let content = "";
+  let created = false;
+  try {
+    content = await fs2.promises.readFile(gitignorePath, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    created = true;
+  }
+  const existing = new Set(
+    content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map(normalizePattern)
+  );
+  const added = patterns.filter(
+    (pattern) => !existing.has(normalizePattern(pattern))
+  );
+  if (added.length === 0) {
+    return { path: gitignorePath, added: [], created: false, changed: false };
+  }
+  let next = content;
+  if (next && !next.endsWith("\n")) next += "\n";
+  if (next) next += "\n";
+  next += ["# Hillclimb hook files", ...added].join("\n");
+  next += "\n";
+  await fs2.promises.writeFile(gitignorePath, next);
+  return {
+    path: gitignorePath,
+    added,
+    created,
+    changed: true
+  };
+}
+
+// src/identity.ts
+import fs3 from "fs";
+import path4 from "path";
+var IDENTITY_PATH = path4.join(configDir(), "identity.json");
 function normalizeUrl(apiBaseUrl) {
   return apiBaseUrl.replace(/\/$/, "");
 }
 async function loadAllIdentities() {
   try {
-    const raw = await fs2.promises.readFile(IDENTITY_PATH, "utf-8");
+    const raw = await fs3.promises.readFile(IDENTITY_PATH, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.identities || typeof parsed.identities !== "object") {
       return { identities: {} };
@@ -149,12 +198,12 @@ async function loadIdentity(apiBaseUrl) {
   return file.identities[normalizeUrl(apiBaseUrl)] ?? null;
 }
 async function writeIdentityFile(file) {
-  await fs2.promises.mkdir(configDir(), { recursive: true, mode: 448 });
+  await fs3.promises.mkdir(configDir(), { recursive: true, mode: 448 });
   const tmp = `${IDENTITY_PATH}.tmp`;
-  await fs2.promises.writeFile(tmp, JSON.stringify(file, null, 2), {
+  await fs3.promises.writeFile(tmp, JSON.stringify(file, null, 2), {
     mode: 384
   });
-  await fs2.promises.rename(tmp, IDENTITY_PATH);
+  await fs3.promises.rename(tmp, IDENTITY_PATH);
 }
 async function saveIdentity(identity) {
   const file = await loadAllIdentities();
@@ -192,8 +241,8 @@ function formatError(err) {
 }
 
 // src/platform/log.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 var PT_TIME_ZONE = "America/Los_Angeles";
 function pacificParts(date) {
   const parts = new Intl.DateTimeFormat("en-US", {
@@ -244,10 +293,10 @@ function pacificDateString(date) {
   return `${p7.year}-${p7.month}-${p7.day}`;
 }
 function logsDir() {
-  return path4.join(configDir(), "logs");
+  return path5.join(configDir(), "logs");
 }
 function todayLogPath() {
-  return path4.join(logsDir(), `${pacificDateString(/* @__PURE__ */ new Date())}.log`);
+  return path5.join(logsDir(), `${pacificDateString(/* @__PURE__ */ new Date())}.log`);
 }
 var logPrefix = "";
 function setLogPrefix(prefix) {
@@ -258,8 +307,8 @@ function appendLog(level, message) {
   const line = `[${pacificTimestamp(/* @__PURE__ */ new Date())}] [${level}]${tag} ${message}
 `;
   try {
-    fs3.mkdirSync(logsDir(), { recursive: true, mode: 448 });
-    fs3.appendFileSync(todayLogPath(), line);
+    fs4.mkdirSync(logsDir(), { recursive: true, mode: 448 });
+    fs4.appendFileSync(todayLogPath(), line);
   } catch {
     process.stderr.write(`hillclimb:${tag} ${level}: ${message}
 `);
@@ -547,9 +596,9 @@ var PlatformClient = class {
 };
 
 // src/platform/hooks.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import os2 from "os";
-import path5 from "path";
+import path6 from "path";
 var HOOK_CMD = (sub) => `npx hillclimb@latest ${sub}`;
 var GIT_TRACES_CMD = (tool) => `npx hillclimb@latest git-traces --tool=${tool}`;
 var CLAUDE_SESSIONEND_UPLOAD_TIMEOUT_SECONDS = 30;
@@ -569,7 +618,7 @@ var TOOLS = [
       { eventName: "Stop", command: GIT_TRACES_CMD("claude") },
       { eventName: "SessionEnd", command: GIT_TRACES_CMD("claude") }
     ],
-    detect: () => isDir(path5.join(os2.homedir(), ".claude"))
+    detect: () => isDir(path6.join(os2.homedir(), ".claude"))
   },
   {
     tool: "cursor",
@@ -582,7 +631,7 @@ var TOOLS = [
       { eventName: "stop", command: GIT_TRACES_CMD("cursor") },
       { eventName: "sessionEnd", command: GIT_TRACES_CMD("cursor") }
     ],
-    detect: () => isDir(path5.join(os2.homedir(), ".cursor"))
+    detect: () => isDir(path6.join(os2.homedir(), ".cursor"))
   },
   {
     // opencode has no settings-file hook system (the `experimental.hook` block
@@ -597,7 +646,7 @@ var TOOLS = [
     format: "opencode",
     events: [],
     // Events are wired inside the plugin itself; see OPENCODE_PLUGIN_CONTENT.
-    detect: () => isDir(path5.join(os2.homedir(), ".local", "share", "opencode")) || isDir(path5.join(os2.homedir(), ".config", "opencode"))
+    detect: () => isDir(path6.join(os2.homedir(), ".local", "share", "opencode")) || isDir(path6.join(os2.homedir(), ".config", "opencode"))
   },
   {
     // VS Code Copilot Chat. Same "no SessionEnd" constraint as Codex (the
@@ -637,23 +686,23 @@ var TOOLS = [
       { eventName: "SessionStart", command: GIT_TRACES_CMD("codex") },
       { eventName: "Stop", command: GIT_TRACES_CMD("codex") }
     ],
-    detect: () => isDir(path5.join(os2.homedir(), ".codex"))
+    detect: () => isDir(path6.join(os2.homedir(), ".codex"))
   }
 ];
 function isDir(p7) {
   try {
-    return fs4.statSync(p7).isDirectory();
+    return fs5.statSync(p7).isDirectory();
   } catch {
     return false;
   }
 }
 function copilotChatDetect() {
   const home = os2.homedir();
-  const suffix = path5.join("User", "globalStorage", "github.copilot-chat");
+  const suffix = path6.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
+    path6.join(home, "Library", "Application Support", "Code", suffix),
+    path6.join(home, ".config", "Code", suffix),
+    process.env.APPDATA ? path6.join(process.env.APPDATA, "Code", suffix) : null
   ].filter((p7) => p7 !== null);
   return candidates.some(isDir);
 }
@@ -662,11 +711,11 @@ function ensureHooks(settings) {
   return settings.hooks;
 }
 function settingsPath(repoRoot, def) {
-  return path5.join(repoRoot, def.settingsFile);
+  return path6.join(repoRoot, def.settingsFile);
 }
 async function readJson(file) {
   try {
-    const raw = await fs4.promises.readFile(file, "utf-8");
+    const raw = await fs5.promises.readFile(file, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
     return {};
@@ -676,8 +725,8 @@ async function readJson(file) {
   }
 }
 async function writeJson(file, obj) {
-  await fs4.promises.mkdir(path5.dirname(file), { recursive: true });
-  await fs4.promises.writeFile(file, `${JSON.stringify(obj, null, 2)}
+  await fs5.promises.mkdir(path6.dirname(file), { recursive: true });
+  await fs5.promises.writeFile(file, `${JSON.stringify(obj, null, 2)}
 `);
 }
 function claudeHookPresent(matchers, command, options = {}) {
@@ -951,19 +1000,19 @@ export default HillclimbPlugin;
 `;
 async function opencodeInstall(file) {
   try {
-    const existing = await fs4.promises.readFile(file, "utf-8");
+    const existing = await fs5.promises.readFile(file, "utf-8");
     if (existing === OPENCODE_PLUGIN_CONTENT) {
       return { installed: 0, alreadyPresent: 1 };
     }
   } catch {
   }
-  await fs4.promises.mkdir(path5.dirname(file), { recursive: true });
-  await fs4.promises.writeFile(file, OPENCODE_PLUGIN_CONTENT);
+  await fs5.promises.mkdir(path6.dirname(file), { recursive: true });
+  await fs5.promises.writeFile(file, OPENCODE_PLUGIN_CONTENT);
   return { installed: 1, alreadyPresent: 0 };
 }
 async function opencodeCheck(file) {
   try {
-    const content = await fs4.promises.readFile(file, "utf-8");
+    const content = await fs5.promises.readFile(file, "utf-8");
     return content.includes(OPENCODE_PLUGIN_MARKER);
   } catch {
     return false;
@@ -1097,17 +1146,17 @@ async function checkAllHooks(repoRoot) {
   }
   return results;
 }
-var CODEX_CONFIG_PATH = path5.join(os2.homedir(), ".codex", "config.toml");
+var CODEX_CONFIG_PATH = path6.join(os2.homedir(), ".codex", "config.toml");
 async function ensureCodexHooksEnabled() {
   let content;
   try {
-    content = await fs4.promises.readFile(CODEX_CONFIG_PATH, "utf-8");
+    content = await fs5.promises.readFile(CODEX_CONFIG_PATH, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
-      await fs4.promises.mkdir(path5.dirname(CODEX_CONFIG_PATH), {
+      await fs5.promises.mkdir(path6.dirname(CODEX_CONFIG_PATH), {
         recursive: true
       });
-      await fs4.promises.writeFile(
+      await fs5.promises.writeFile(
         CODEX_CONFIG_PATH,
         "[features]\nhooks = true\n"
       );
@@ -1148,7 +1197,7 @@ hooks = true
 `;
   }
   if (content === original) return false;
-  await fs4.promises.writeFile(CODEX_CONFIG_PATH, content);
+  await fs5.promises.writeFile(CODEX_CONFIG_PATH, content);
   return true;
 }
 var CLAUDE_DEF = TOOLS[0];
@@ -1571,6 +1620,29 @@ async function runInit(args = []) {
           p3.log.success(`Installed ${r.label} hook`);
         }
       }
+      try {
+        const ignored = await ensureGitignored(
+          repoRoot,
+          hookResults.map((r) => r.settingsFile)
+        );
+        if (ignored.changed) {
+          appendLog(
+            "info",
+            `init: gitignored hook files (${ignored.added.join(",")})`
+          );
+          p3.log.success(
+            `${ignored.created ? "Created" : "Updated"} .gitignore for hook files`
+          );
+        }
+      } catch (err) {
+        appendLog(
+          "warn",
+          `init: could not update .gitignore for hook files: ${formatError(err)}`
+        );
+        p3.log.warn(
+          `Could not update .gitignore for hook files: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
       if (hookResults.some((r) => r.tool === "codex")) {
         try {
           const changed = await ensureCodexHooksEnabled();
@@ -1821,7 +1893,7 @@ async function runLogout(args = []) {
 }
 
 // src/commands/status.ts
-import path6 from "path";
+import path7 from "path";
 async function runStatus(args = []) {
   const debug = args.includes("--debug");
   header("status");
@@ -1839,7 +1911,7 @@ async function runStatus(args = []) {
     return;
   }
   const { repoRoot, config } = match;
-  const repoName = repo?.name ?? path6.basename(repoRoot);
+  const repoName = repo?.name ?? path7.basename(repoRoot);
   if (IS_TTY) {
     process.stdout.write(`  ${dim("Checking login...")}`);
   }
@@ -1933,7 +2005,7 @@ async function runStatus(args = []) {
   try {
     const hookStatuses = await checkAllHooks(repoRoot);
     for (const h of hookStatuses) {
-      const rel = path6.relative(repoRoot, h.settingsFile) || h.settingsFile;
+      const rel = path7.relative(repoRoot, h.settingsFile) || h.settingsFile;
       debugRow(
         `${h.label} hook:`,
         `${rel} ${dim(`(${h.installed ? "installed" : "missing"})`)}`
@@ -1950,20 +2022,20 @@ async function runStatus(args = []) {
 
 // src/commands/upload.ts
 import { spawn as spawn2 } from "child_process";
-import fs8 from "fs";
+import fs9 from "fs";
 import os5 from "os";
-import path11 from "path";
+import path12 from "path";
 
 // src/middleware/pattern-redact.ts
 import os3 from "os";
 import { Worker } from "worker_threads";
 
 // src/middleware/file-utils.ts
-import fs5 from "fs";
+import fs6 from "fs";
 async function checkBinary(filePath) {
   let handle = null;
   try {
-    handle = await fs5.promises.open(filePath, "r");
+    handle = await fs6.promises.open(filePath, "r");
     const buf = Buffer.alloc(8192);
     const { bytesRead } = await handle.read(buf, 0, 8192, 0);
     for (let i = 0; i < bytesRead; i++) {
@@ -1988,7 +2060,7 @@ async function readFileContent(file) {
     return { kind: "binary" };
   }
   try {
-    const content = await fs5.promises.readFile(file.absolutePath, "utf-8");
+    const content = await fs6.promises.readFile(file.absolutePath, "utf-8");
     return { kind: "text", content };
   } catch {
     return { kind: "error" };
@@ -10440,8 +10512,8 @@ var RedactMiddleware = class {
 var middleware = [];
 
 // src/middleware/secrets.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path8 from "path";
 var KNOWN_NON_SECRETS = /* @__PURE__ */ new Set([
   "true",
   "false",
@@ -10521,7 +10593,7 @@ async function parseEnvFile(filePath) {
   const values = [];
   let content;
   try {
-    content = await fs6.promises.readFile(filePath, "utf-8");
+    content = await fs7.promises.readFile(filePath, "utf-8");
   } catch {
     return values;
   }
@@ -10589,16 +10661,16 @@ function addWithVariants(set, value) {
 async function discoverEnvFiles(repoRoot) {
   let entries;
   try {
-    entries = await fs6.promises.readdir(repoRoot);
+    entries = await fs7.promises.readdir(repoRoot);
   } catch {
     return [];
   }
   const envFiles = [];
   for (const name of entries) {
     if (!name.startsWith(".env")) continue;
-    const filePath = path7.join(repoRoot, name);
+    const filePath = path8.join(repoRoot, name);
     try {
-      const stat = await fs6.promises.stat(filePath);
+      const stat = await fs7.promises.stat(filePath);
       if (stat.isFile()) envFiles.push(name);
     } catch {
     }
@@ -10621,7 +10693,7 @@ async function collectSecrets(repoRoot, envFiles, additionalFiles) {
     }
   }
   for (const filePath of additionalFiles) {
-    const resolved = path7.resolve(repoRoot, filePath);
+    const resolved = path8.resolve(repoRoot, filePath);
     sourceFiles.push(resolved);
     for (const value of await parseEnvFile(resolved)) {
       if (isUsableValue(value)) {
@@ -10646,7 +10718,7 @@ async function collectSecrets(repoRoot, envFiles, additionalFiles) {
 }
 
 // src/normalizer/index.ts
-import path8 from "path";
+import path9 from "path";
 
 // src/normalizer/claude.ts
 function stringify(value) {
@@ -11514,7 +11586,7 @@ var NormalizeMiddleware = class {
       if (!["claude", "codex", "cursor"].includes(file.sourceName)) continue;
       const content = file.content ? file.content.toString("utf-8") : null;
       if (!content) continue;
-      const sessionId = file.metadata?.sessionId ?? path8.basename(file.absolutePath, ".jsonl");
+      const sessionId = file.metadata?.sessionId ?? path9.basename(file.absolutePath, ".jsonl");
       try {
         const trajectory = normalizeContent(
           file.sourceName,
@@ -11548,14 +11620,14 @@ import archiver from "archiver";
 
 // src/outputs/archive.ts
 import os4 from "os";
-import path9 from "path";
+import path10 from "path";
 function getSourceBaseDir(sourceName) {
   const home = os4.homedir();
   switch (sourceName) {
     case "claude":
-      return path9.join(home, ".claude", "projects");
+      return path10.join(home, ".claude", "projects");
     case "codex":
-      return path9.join(home, ".codex", "sessions");
+      return path10.join(home, ".codex", "sessions");
     default:
       return home;
   }
@@ -11564,8 +11636,8 @@ function addGroupToArchive(archive, group, selectedSources) {
   for (const file of group.files) {
     if (!selectedSources.has(file.sourceName)) continue;
     const baseDir = getSourceBaseDir(file.sourceName);
-    const relativePath = file.absolutePath.startsWith(baseDir) ? path9.relative(baseDir, file.absolutePath) : path9.basename(file.absolutePath);
-    const archivePath = path9.join(file.sourceName, relativePath);
+    const relativePath = file.absolutePath.startsWith(baseDir) ? path10.relative(baseDir, file.absolutePath) : path10.basename(file.absolutePath);
+    const archivePath = path10.join(file.sourceName, relativePath);
     if (file.content) {
       archive.append(file.content, { name: archivePath });
     } else {
@@ -11639,21 +11711,21 @@ var PlatformUploadOutput = class {
 };
 
 // src/pipeline.ts
-import fs7 from "fs";
-import path10 from "path";
+import fs8 from "fs";
+import path11 from "path";
 function canonicalizePath(p7) {
-  let resolved = path10.resolve(p7);
-  if (resolved.endsWith(path10.sep) && resolved !== path10.sep) {
+  let resolved = path11.resolve(p7);
+  if (resolved.endsWith(path11.sep) && resolved !== path11.sep) {
     resolved = resolved.slice(0, -1);
   }
   return resolved;
 }
 function computeLabel(repoPath, allPaths) {
-  const segments = repoPath.split(path10.sep).filter(Boolean);
+  const segments = repoPath.split(path11.sep).filter(Boolean);
   for (let depth = 1; depth <= segments.length; depth++) {
     const label = segments.slice(-depth).join("/");
     const matches = allPaths.filter((p7) => {
-      const s = p7.split(path10.sep).filter(Boolean);
+      const s = p7.split(path11.sep).filter(Boolean);
       return s.slice(-depth).join("/") === label;
     });
     if (matches.length === 1) return label;
@@ -11675,7 +11747,7 @@ async function mergeByRepo(files) {
   const groups = [];
   for (const [repoPath, groupFiles] of grouped) {
     const stats = await Promise.all(
-      groupFiles.map((f) => fs7.promises.stat(f.absolutePath).catch(() => null))
+      groupFiles.map((f) => fs8.promises.stat(f.absolutePath).catch(() => null))
     );
     let lastModified = /* @__PURE__ */ new Date(0);
     for (const stat of stats) {
@@ -11698,7 +11770,7 @@ async function preloadFiles(group) {
     group.files.map(async (file) => {
       if (file.content) return file;
       try {
-        const buf = await fs7.promises.readFile(file.absolutePath);
+        const buf = await fs8.promises.readFile(file.absolutePath);
         const checkLen = Math.min(buf.length, 8192);
         for (let i = 0; i < checkLen; i++) {
           if (buf[i] === 0) {
@@ -11743,7 +11815,7 @@ 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" });
+  const stream = fs9.createReadStream(transcriptPath, { encoding: "utf-8" });
   let buffer = "";
   try {
     for await (const chunk of stream) {
@@ -11776,7 +11848,7 @@ function resolveCursorTranscriptPath(payload) {
   const workspace = payload.workspace_roots?.[0];
   if (!id || !workspace) return void 0;
   const encoded = workspace.replace(/^\//, "").replace(/\//g, "-");
-  return path11.join(
+  return path12.join(
     os5.homedir(),
     ".cursor",
     "projects",
@@ -11802,9 +11874,9 @@ async function runUploadInner(payload) {
     );
     return;
   }
-  const transcriptResolved = path11.resolve(transcriptPath);
+  const transcriptResolved = path12.resolve(transcriptPath);
   try {
-    const stat = await fs8.promises.stat(transcriptResolved);
+    const stat = await fs9.promises.stat(transcriptResolved);
     if (!stat.isFile()) {
       appendLog(
         "warn",
@@ -11853,13 +11925,13 @@ async function uploadSession(args) {
   };
   const group = {
     repoPath: repoRoot,
-    label: path11.basename(repoRoot),
+    label: path12.basename(repoRoot),
     files: [sourceFile],
     sourceNames: [sourceTool],
     lastModified: now
   };
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path11.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path12.join(repoRoot, n));
   const secretResult = await collectSecrets(repoRoot, envFilePaths, []);
   const mwChain = [];
   if (secretResult.values.size > 0) {
@@ -12039,9 +12111,9 @@ import { execFileSync as execFileSync2 } from "child_process";
 
 // src/git-traces/git-ops.ts
 import { execFileSync } from "child_process";
-import fs9 from "fs";
+import fs10 from "fs";
 import os6 from "os";
-import path12 from "path";
+import path13 from "path";
 import { gzipSync } from "zlib";
 var GIT_COMMAND_TIMEOUT_MS = 12e4;
 var EXEC_OPTS = {
@@ -12165,7 +12237,7 @@ function buildUntrackedTree(repoRoot) {
   for (const relPath of list.split("\0")) {
     if (!relPath) continue;
     try {
-      const stat = fs9.lstatSync(path12.join(repoRoot, relPath));
+      const stat = fs10.lstatSync(path13.join(repoRoot, relPath));
       if (stat.size > MAX_UNTRACKED_FILE_BYTES) {
         appendLog(
           "warn",
@@ -12178,7 +12250,7 @@ function buildUntrackedTree(repoRoot) {
     }
   }
   if (kept.length === 0) return null;
-  const tmpIndex = path12.join(
+  const tmpIndex = path13.join(
     os6.tmpdir(),
     `hillclimb-untracked-${Date.now()}-${process.pid}`
   );
@@ -12191,7 +12263,7 @@ function buildUntrackedTree(repoRoot) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs9.unlinkSync(tmpIndex);
+      fs10.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -12202,7 +12274,7 @@ function buildSnapshotTree(repoRoot, stashSha) {
   if (!untrackedTree || untrackedTree === EMPTY_TREE_SHA) {
     return trackedTree;
   }
-  const tmpIndex = path12.join(
+  const tmpIndex = path13.join(
     os6.tmpdir(),
     `hillclimb-index-${Date.now()}-${process.pid}`
   );
@@ -12230,7 +12302,7 @@ function buildSnapshotTree(repoRoot, stashSha) {
     return gitWithEnv(repoRoot, ["write-tree"], env);
   } finally {
     try {
-      fs9.unlinkSync(tmpIndex);
+      fs10.unlinkSync(tmpIndex);
     } catch {
     }
   }
@@ -12244,16 +12316,16 @@ function createBundleFromTree(repoRoot, treeSha, sessionId, label) {
   ]);
   const orphanRef = `refs/hillclimb/bundle/${sessionId}`;
   pinRef(repoRoot, orphanRef, orphanCommit);
-  const tmpFile = path12.join(
+  const tmpFile = path13.join(
     os6.tmpdir(),
     `hillclimb-bundle-${Date.now()}.bundle`
   );
   try {
     git(repoRoot, ["bundle", "create", tmpFile, orphanRef]);
-    return fs9.readFileSync(tmpFile);
+    return fs10.readFileSync(tmpFile);
   } finally {
     try {
-      fs9.unlinkSync(tmpFile);
+      fs10.unlinkSync(tmpFile);
     } catch {
     }
     deleteRef(repoRoot, orphanRef);
@@ -12406,9 +12478,9 @@ function parseCommitFiles(repoRoot, sha) {
         oldPath
       });
     } else {
-      const path20 = parts[parts.length - 1];
-      indexByPath.set(path20, files.length);
-      files.push({ path: path20, status, additions: 0, deletions: 0 });
+      const path21 = parts[parts.length - 1];
+      indexByPath.set(path21, files.length);
+      files.push({ path: path21, status, additions: 0, deletions: 0 });
     }
   }
   for (const line of numstat.split("\n")) {
@@ -12462,21 +12534,21 @@ function cleanupSessionRefs(repoRoot, sessionId) {
 
 // src/git-traces/session-state.ts
 import crypto from "crypto";
-import fs10 from "fs";
+import fs11 from "fs";
 import os7 from "os";
-import path13 from "path";
+import path14 from "path";
 var CURRENT_SCHEMA_VERSION = 3;
-var STATE_DIR = path13.join(os7.homedir(), ".hillclimb", "git-traces");
+var STATE_DIR = path14.join(os7.homedir(), ".hillclimb", "git-traces");
 function stateFileForRepo(repoRoot, tool) {
-  const hash = crypto.createHash("sha256").update(`${path13.resolve(repoRoot)}\0${tool}`).digest("hex").slice(0, 16);
-  return path13.join(STATE_DIR, `${hash}.json`);
+  const hash = crypto.createHash("sha256").update(`${path14.resolve(repoRoot)}\0${tool}`).digest("hex").slice(0, 16);
+  return path14.join(STATE_DIR, `${hash}.json`);
 }
 function lockFileForRepo(repoRoot, tool) {
   return `${stateFileForRepo(repoRoot, tool)}.lock`;
 }
 async function readSessionState(repoRoot, tool) {
   try {
-    const raw = await fs10.promises.readFile(
+    const raw = await fs11.promises.readFile(
       stateFileForRepo(repoRoot, tool),
       "utf-8"
     );
@@ -12491,27 +12563,27 @@ async function readSessionState(repoRoot, tool) {
 }
 async function writeSessionState(state, tool) {
   const file = stateFileForRepo(state.repoRoot, tool);
-  await fs10.promises.mkdir(STATE_DIR, { recursive: true, mode: 448 });
+  await fs11.promises.mkdir(STATE_DIR, { recursive: true, mode: 448 });
   const tmp = `${file}.tmp`;
-  await fs10.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
+  await fs11.promises.writeFile(tmp, JSON.stringify(state, null, 2), {
     mode: 384
   });
-  await fs10.promises.rename(tmp, file);
+  await fs11.promises.rename(tmp, file);
 }
 async function deleteSessionState(repoRoot, tool) {
   try {
-    await fs10.promises.unlink(stateFileForRepo(repoRoot, tool));
+    await fs11.promises.unlink(stateFileForRepo(repoRoot, tool));
   } catch {
   }
 }
 async function acquireLock(repoRoot, tool, retries = 3, delayMs = 200) {
   const lockPath = lockFileForRepo(repoRoot, tool);
-  await fs10.promises.mkdir(STATE_DIR, { recursive: true, mode: 448 });
+  await fs11.promises.mkdir(STATE_DIR, { recursive: true, mode: 448 });
   for (let i = 0; i < retries; i++) {
     try {
-      const fd = await fs10.promises.open(
+      const fd = await fs11.promises.open(
         lockPath,
-        fs10.constants.O_CREAT | fs10.constants.O_EXCL | fs10.constants.O_WRONLY
+        fs11.constants.O_CREAT | fs11.constants.O_EXCL | fs11.constants.O_WRONLY
       );
       await fd.write(String(process.pid));
       await fd.close();
@@ -12528,7 +12600,7 @@ async function acquireLock(repoRoot, tool, retries = 3, delayMs = 200) {
 }
 async function releaseLock(repoRoot, tool) {
   try {
-    await fs10.promises.unlink(lockFileForRepo(repoRoot, tool));
+    await fs11.promises.unlink(lockFileForRepo(repoRoot, tool));
   } catch {
   }
 }
@@ -12574,14 +12646,16 @@ function execGit(cwd, args) {
     maxBuffer: 50 * 1024 * 1024
   }).toString("utf-8").trim();
 }
+function canUploadFile(filename, buffer) {
+  if (buffer.byteLength <= MAX_UPLOAD_BYTES) return true;
+  appendLog(
+    "warn",
+    `git-traces: skipping ${filename} (${buffer.byteLength} bytes > ${MAX_UPLOAD_BYTES} limit)`
+  );
+  return false;
+}
 async function uploadFile(client, contributionId, filename, mimeType, buffer) {
-  if (buffer.byteLength > MAX_UPLOAD_BYTES) {
-    appendLog(
-      "warn",
-      `git-traces: skipping ${filename} (${buffer.byteLength} bytes > ${MAX_UPLOAD_BYTES} limit)`
-    );
-    return;
-  }
+  if (!canUploadFile(filename, buffer)) return false;
   const presigned = await client.createUpload(contributionId, {
     originalFilename: filename,
     mimeType,
@@ -12596,6 +12670,11 @@ async function uploadFile(client, contributionId, filename, mimeType, buffer) {
     "info",
     `git-traces: uploaded ${filename} (${buffer.byteLength} bytes)`
   );
+  return true;
+}
+function canUploadEpochBaselineArtifacts(epoch, artifacts) {
+  const prefix = epochPrefix(epoch);
+  return canUploadFile(`${prefix}-baseline.bundle`, artifacts.bundleBuffer) && canUploadFile(`${prefix}-baseline.json`, artifacts.metadataBuffer);
 }
 function pinEpochBaseline(repoRoot, sessionId, epoch) {
   const baselineSha = captureBaselineSha(repoRoot);
@@ -12650,30 +12729,34 @@ function buildEpochBaselineArtifacts(params) {
 async function uploadEpochBaselineArtifacts(params) {
   const { client, contributionId, epoch, artifacts } = params;
   const prefix = epochPrefix(epoch);
-  await uploadFile(
-    client,
-    contributionId,
-    `${prefix}-baseline.json`,
-    "application/json",
-    artifacts.metadataBuffer
-  );
-  await uploadFile(
+  if (!canUploadEpochBaselineArtifacts(epoch, artifacts)) return false;
+  const bundleUploaded = await uploadFile(
     client,
     contributionId,
     `${prefix}-baseline.bundle`,
     "application/x-git-bundle",
     artifacts.bundleBuffer
   );
+  if (!bundleUploaded) return false;
+  return uploadFile(
+    client,
+    contributionId,
+    `${prefix}-baseline.json`,
+    "application/json",
+    artifacts.metadataBuffer
+  );
 }
 async function uploadEpochBaseline(params) {
   const artifacts = buildEpochBaselineArtifacts(params);
   if (!artifacts) return null;
-  await uploadEpochBaselineArtifacts({
+  if (!canUploadEpochBaselineArtifacts(params.epoch, artifacts)) return null;
+  const uploaded = await uploadEpochBaselineArtifacts({
     client: params.client,
     contributionId: params.contributionId,
     epoch: params.epoch,
     artifacts
   });
+  if (!uploaded) return null;
   return { baselineTreeSha: artifacts.baselineTreeSha };
 }
 async function openEpoch(params) {
@@ -12783,6 +12866,7 @@ async function handleStop(payload, tool) {
         startedAt: state.startedAt
       });
       if (!artifacts) return;
+      if (!canUploadEpochBaselineArtifacts(1, artifacts)) return;
       const toolLabel = TOOL_LABELS[tool] ?? "Claude";
       const now = /* @__PURE__ */ new Date();
       const epochSeconds = formatEpochSeconds2(now);
@@ -12798,12 +12882,13 @@ Repo: ${cwd}
 Uploaded: ${now.toISOString()}`
         }
       );
-      await uploadEpochBaselineArtifacts({
+      const uploaded = await uploadEpochBaselineArtifacts({
         client,
         contributionId: contribution.id,
         epoch: 1,
         artifacts
       });
+      if (!uploaded) return;
       await client.submitContribution(contribution.id);
       state.contributionId = contribution.id;
       state.baselineTreeSha = artifacts.baselineTreeSha;
@@ -13100,15 +13185,15 @@ ${stack}` : ""}`
 }
 
 // src/outputs/zip.ts
-import fs12 from "fs";
-import path15 from "path";
+import fs13 from "fs";
+import path16 from "path";
 import archiver2 from "archiver";
 
 // src/outputs/downloads.ts
 import { execSync as execSync2 } from "child_process";
-import fs11 from "fs";
+import fs12 from "fs";
 import os8 from "os";
-import path14 from "path";
+import path15 from "path";
 function getDownloadsFolder() {
   const home = os8.homedir();
   if (process.platform === "linux") {
@@ -13117,12 +13202,12 @@ function getDownloadsFolder() {
         encoding: "utf-8",
         timeout: 3e3
       }).trim();
-      if (xdgDir && fs11.existsSync(xdgDir)) return xdgDir;
+      if (xdgDir && fs12.existsSync(xdgDir)) return xdgDir;
     } catch {
     }
   }
-  const downloads = path14.join(home, "Downloads");
-  if (fs11.existsSync(downloads)) return downloads;
+  const downloads = path15.join(home, "Downloads");
+  if (fs12.existsSync(downloads)) return downloads;
   return home;
 }
 
@@ -13131,11 +13216,11 @@ function sanitizeFilename(name) {
   return name.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
 function getUniqueFilename(dir, base, ext) {
-  let candidate = path15.join(dir, `${base}${ext}`);
-  if (!fs12.existsSync(candidate)) return candidate;
+  let candidate = path16.join(dir, `${base}${ext}`);
+  if (!fs13.existsSync(candidate)) return candidate;
   let i = 1;
-  while (fs12.existsSync(candidate)) {
-    candidate = path15.join(dir, `${base}-${i}${ext}`);
+  while (fs13.existsSync(candidate)) {
+    candidate = path16.join(dir, `${base}-${i}${ext}`);
     i++;
   }
   return candidate;
@@ -13145,13 +13230,13 @@ var ZipOutput = class {
   label = "Save as .zip to Downloads";
   async emit(group, options) {
     const downloadsDir = getDownloadsFolder();
-    const repoName = sanitizeFilename(path15.basename(group.repoPath));
+    const repoName = sanitizeFilename(path16.basename(group.repoPath));
     const timeRange = options.timeRange;
     const rangePart = timeRange?.label ?? "all";
     const epochSeconds = Math.floor(Date.now() / 1e3);
     const baseName = `logs-${repoName}-${rangePart}-${epochSeconds}`;
     const outputPath = getUniqueFilename(downloadsDir, baseName, ".zip");
-    const output = fs12.createWriteStream(outputPath);
+    const output = fs13.createWriteStream(outputPath);
     const archive = archiver2("zip", { zlib: { level: 6 } });
     const done = new Promise((resolve, reject) => {
       output.on("close", resolve);
@@ -13345,15 +13430,15 @@ async function confirmExport(group, output) {
 }
 
 // src/sources/claude.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import os9 from "os";
-import path16 from "path";
+import path17 from "path";
 import readline from "readline";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["tool-results"]);
 async function resolveRepoPath(projectDir) {
-  const indexPath = path16.join(projectDir, "sessions-index.json");
+  const indexPath = path17.join(projectDir, "sessions-index.json");
   try {
-    const raw = await fs13.promises.readFile(indexPath, "utf-8");
+    const raw = await fs14.promises.readFile(indexPath, "utf-8");
     const data = JSON.parse(raw);
     if (data.originalPath && typeof data.originalPath === "string") {
       return data.originalPath;
@@ -13361,12 +13446,12 @@ async function resolveRepoPath(projectDir) {
   } catch {
   }
   const cwdCounts = /* @__PURE__ */ new Map();
-  const entries = await fs13.promises.readdir(projectDir, {
+  const entries = await fs14.promises.readdir(projectDir, {
     withFileTypes: true
   });
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-    const cwd = await extractCwdFromJsonl(path16.join(projectDir, entry.name));
+    const cwd = await extractCwdFromJsonl(path17.join(projectDir, entry.name));
     if (cwd) {
       cwdCounts.set(cwd, (cwdCounts.get(cwd) ?? 0) + 1);
     }
@@ -13385,7 +13470,7 @@ async function resolveRepoPath(projectDir) {
   return null;
 }
 async function extractCwdFromJsonl(filePath) {
-  const stream = fs13.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs14.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -13407,12 +13492,12 @@ async function extractCwdFromJsonl(filePath) {
 async function collectFiles(dir, baseDir, sourceName, repoPath, results) {
   let entries;
   try {
-    entries = await fs13.promises.readdir(dir, { withFileTypes: true });
+    entries = await fs14.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path16.join(dir, entry.name);
+    const fullPath = path17.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
       await collectFiles(fullPath, baseDir, sourceName, repoPath, results);
@@ -13434,19 +13519,19 @@ function fallbackDecode(encodedName) {
 var ClaudeSource = class {
   name = "claude";
   async scan() {
-    const baseDir = path16.join(os9.homedir(), ".claude", "projects");
+    const baseDir = path17.join(os9.homedir(), ".claude", "projects");
     try {
-      await fs13.promises.access(baseDir);
+      await fs14.promises.access(baseDir);
     } catch {
       return [];
     }
-    const projectDirs = await fs13.promises.readdir(baseDir, {
+    const projectDirs = await fs14.promises.readdir(baseDir, {
       withFileTypes: true
     });
     const dirEntries = projectDirs.filter((d) => d.isDirectory());
     const resultArrays = await Promise.all(
       dirEntries.map(async (dir) => {
-        const projectPath = path16.join(baseDir, dir.name);
+        const projectPath = path17.join(baseDir, dir.name);
         const repoPath = await resolveRepoPath(projectPath) ?? fallbackDecode(dir.name);
         const files = [];
         await collectFiles(
@@ -13464,12 +13549,12 @@ var ClaudeSource = class {
 };
 
 // src/sources/codex.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import os10 from "os";
-import path17 from "path";
+import path18 from "path";
 import readline2 from "readline";
 async function parseSessionMeta(filePath) {
-  const stream = fs14.createReadStream(filePath, { encoding: "utf-8" });
+  const stream = fs15.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -13494,12 +13579,12 @@ async function findJsonlFiles(dir) {
   async function walk(d) {
     let entries;
     try {
-      entries = await fs14.promises.readdir(d, { withFileTypes: true });
+      entries = await fs15.promises.readdir(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path17.join(d, entry.name);
+      const full = path18.join(d, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -13513,11 +13598,11 @@ async function findJsonlFiles(dir) {
 async function loadHistory(historyPath) {
   const map = /* @__PURE__ */ new Map();
   try {
-    await fs14.promises.access(historyPath);
+    await fs15.promises.access(historyPath);
   } catch {
     return map;
   }
-  const stream = fs14.createReadStream(historyPath, { encoding: "utf-8" });
+  const stream = fs15.createReadStream(historyPath, { encoding: "utf-8" });
   const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of rl) {
@@ -13544,14 +13629,14 @@ async function loadHistory(historyPath) {
 var CodexSource = class {
   name = "codex";
   async scan() {
-    const codexDir = path17.join(os10.homedir(), ".codex");
-    const sessionsDir = path17.join(codexDir, "sessions");
+    const codexDir = path18.join(os10.homedir(), ".codex");
+    const sessionsDir = path18.join(codexDir, "sessions");
     try {
-      await fs14.promises.access(sessionsDir);
+      await fs15.promises.access(sessionsDir);
     } catch {
       return [];
     }
-    const historyPath = path17.join(codexDir, "history.jsonl");
+    const historyPath = path18.join(codexDir, "history.jsonl");
     const [jsonlFiles, historyMap] = await Promise.all([
       findJsonlFiles(sessionsDir),
       loadHistory(historyPath)
@@ -13574,8 +13659,8 @@ var CodexSource = class {
       });
       const historyLines = historyMap.get(meta.sessionId);
       if (historyLines) {
-        const sessionDir = path17.relative(sessionsDir, path17.dirname(filePath));
-        const historyAbsPath = path17.join(
+        const sessionDir = path18.relative(sessionsDir, path18.dirname(filePath));
+        const historyAbsPath = path18.join(
           sessionsDir,
           sessionDir,
           `history-${meta.sessionId}.jsonl`
@@ -13595,18 +13680,18 @@ var CodexSource = class {
 };
 
 // src/sources/copilotChat.ts
-import fs15 from "fs";
+import fs16 from "fs";
 import os11 from "os";
-import path18 from "path";
+import path19 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")
+    path19.join(home, "Library", "Application Support", "Code", "User"),
+    path19.join(home, ".config", "Code", "User")
   ];
   if (process.env.APPDATA) {
-    dirs.push(path18.join(process.env.APPDATA, "Code", "User"));
+    dirs.push(path19.join(process.env.APPDATA, "Code", "User"));
   }
   return dirs;
 }
@@ -13621,7 +13706,7 @@ function uriToFsPath(uri) {
 async function readWorkspaceFolder(workspaceJsonPath) {
   let raw;
   try {
-    raw = await fs15.promises.readFile(workspaceJsonPath, "utf-8");
+    raw = await fs16.promises.readFile(workspaceJsonPath, "utf-8");
   } catch {
     return null;
   }
@@ -13643,10 +13728,10 @@ var CopilotChatSource = class {
   async scan() {
     const results = [];
     for (const userDir of vsCodeUserDirs()) {
-      const workspaceStorage = path18.join(userDir, "workspaceStorage");
+      const workspaceStorage = path19.join(userDir, "workspaceStorage");
       let hashDirs;
       try {
-        hashDirs = await fs15.promises.readdir(workspaceStorage, {
+        hashDirs = await fs16.promises.readdir(workspaceStorage, {
           withFileTypes: true
         });
       } catch {
@@ -13654,22 +13739,22 @@ var CopilotChatSource = class {
       }
       for (const hash of hashDirs) {
         if (!hash.isDirectory()) continue;
-        const wsRoot = path18.join(workspaceStorage, hash.name);
-        const transcriptsDir = path18.join(
+        const wsRoot = path19.join(workspaceStorage, hash.name);
+        const transcriptsDir = path19.join(
           wsRoot,
           "GitHub.copilot-chat",
           "transcripts"
         );
         let transcriptEntries;
         try {
-          transcriptEntries = await fs15.promises.readdir(transcriptsDir, {
+          transcriptEntries = await fs16.promises.readdir(transcriptsDir, {
             withFileTypes: true
           });
         } catch {
           continue;
         }
         const repoPath = await readWorkspaceFolder(
-          path18.join(wsRoot, "workspace.json")
+          path19.join(wsRoot, "workspace.json")
         );
         if (!repoPath) continue;
         for (const entry of transcriptEntries) {
@@ -13677,7 +13762,7 @@ var CopilotChatSource = class {
           const sessionId = entry.name.slice(0, -".jsonl".length);
           results.push({
             sourceName: this.name,
-            absolutePath: path18.join(transcriptsDir, entry.name),
+            absolutePath: path19.join(transcriptsDir, entry.name),
             repoPath,
             metadata: { sessionId }
           });
@@ -13717,7 +13802,7 @@ function reportRedactionStats(noun, stats) {
 async function filterByTimeRange(group, range) {
   const results = await Promise.all(
     group.files.map(
-      (f) => fs16.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
+      (f) => fs17.promises.stat(f.absolutePath).then((s) => ({ file: f, stat: s })).catch(() => null)
     )
   );
   const filtered = [];
@@ -13744,10 +13829,10 @@ async function runInteractive() {
   s.start(`Scanning ${source.name} logs...`);
   const allFiles = await source.scan();
   const allGroups = await mergeByRepo(allFiles);
-  const repoRoot = path19.resolve(repo.root);
+  const repoRoot = path20.resolve(repo.root);
   const matching = allGroups.filter((g) => {
-    const resolved = path19.resolve(g.repoPath);
-    return resolved === repoRoot || resolved.startsWith(repoRoot + path19.sep);
+    const resolved = path20.resolve(g.repoPath);
+    return resolved === repoRoot || resolved.startsWith(repoRoot + path20.sep);
   });
   if (matching.length === 0) {
     s.stop(`No ${source.name} logs found for ${repo.name}.`);
@@ -13778,7 +13863,7 @@ async function runInteractive() {
     }
   }
   const envFileNames = await discoverEnvFiles(repoRoot);
-  const envFilePaths = envFileNames.map((n) => path19.join(repoRoot, n));
+  const envFilePaths = envFileNames.map((n) => path20.join(repoRoot, n));
   const additionalFiles = await promptSecretFiles(envFileNames);
   const secretResult = await collectSecrets(
     repoRoot,

package/package.json

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