hillclimb 0.9.1 → 0.9.3

package/dist/{chunk-JZC2F6VA.js → chunk-UPXMA7RC.js}

@@ -160,7 +160,7 @@ async function repoIdentity(repoRoot) {
 }
 async function logHeal(level, message) {
   try {
-    const { appendLog: appendLog2 } = await import("./log-6OIO3F7C.js");
+    const { appendLog: appendLog2 } = await import("./log-UZPPBFMO.js");
     appendLog2(level, message);
   } catch {
   }
@@ -182,7 +182,7 @@ function matchByPath(projects, resolved) {
 var healMisses = /* @__PURE__ */ new Set();
 async function healRenamedProject(file, resolved) {
   const dead = Object.entries(file.projects).filter(
-    ([key]) => !fs.existsSync(path.resolve(key))
+    ([key]) => pathIsGone(path.resolve(key))
   );
   if (dead.length === 0) return null;
   const missKey = `${configPath()}|${resolved}`;
@@ -288,11 +288,26 @@ async function matchLinkedWorktree(projects, resolved) {
   }
   return null;
 }
+function hasNestedGitFile(root, target) {
+  let dir = target;
+  while (dir !== root && dir.startsWith(root + path.sep)) {
+    try {
+      if (fs.statSync(path.join(dir, ".git")).isFile()) return true;
+    } catch {
+    }
+    dir = path.dirname(dir);
+  }
+  return false;
+}
 async function findProjectForCwd(cwd) {
   const file = await loadProjects();
   const resolved = path.resolve(cwd);
   const match = matchByPath(file.projects, resolved);
   if (match) {
+    if (hasNestedGitFile(match.repoRoot, resolved)) {
+      const nested = await matchLinkedWorktree(file.projects, resolved);
+      if (nested) return nested;
+    }
     await backfillIdentity(file, match);
     return { repoRoot: match.repoRoot, config: match.config };
   }
@@ -383,5 +398,6 @@ export {
   configPath,
   loadProjects,
   upsertProject,
+  hasNestedGitFile,
   findProjectForCwd
 };

package/dist/{log-6OIO3F7C.js → log-UZPPBFMO.js}

@@ -3,7 +3,7 @@ import {
   appendLog,
   setLogPrefix,
   todayLogPath
-} from "./chunk-JZC2F6VA.js";
+} from "./chunk-UPXMA7RC.js";
 export {
   appendLog,
   setLogPrefix,

package/dist/main.js

@@ -5,11 +5,12 @@ import {
   configDir,
   configPath,
   findProjectForCwd,
+  hasNestedGitFile,
   loadProjects,
   setLogPrefix,
   todayLogPath,
   upsertProject
-} from "./chunk-JZC2F6VA.js";
+} from "./chunk-UPXMA7RC.js";
 
 // src/main.ts
 import fs27 from "fs";
@@ -568,7 +569,7 @@ var PlatformClient = class {
     const sizeBytes = body.kind === "buffer" ? body.buffer.length : body.sizeBytes;
     const prefix = `/api/v1/contributions/${encodeURIComponent(contributionId)}`;
     let digest;
-    const verify = async (uploadId) => {
+    const verify = async (uploadId, options = {}) => {
       if (digest === void 0) {
         const hash = createHash("sha256");
         let localSize = 0;
@@ -590,7 +591,8 @@ var PlatformClient = class {
       return this.verifyReplayArtifact(
         `${prefix}/uploads/${encodeURIComponent(uploadId)}/download`,
         sizeBytes,
-        digest
+        digest,
+        options
       );
     };
     const put = async (target2) => {
@@ -642,7 +644,7 @@ var PlatformClient = class {
           "UPLOAD_REPLAY_MISMATCH"
         );
       }
-      const verified = await verify(existing.id);
+      const verified = await verify(existing.id, { forbiddenIsAbsent: true });
       if (verified.exists) return;
       target = await this.request(
         "POST",
@@ -665,7 +667,7 @@ var PlatformClient = class {
     }
     await put(target);
   }
-  async verifyReplayArtifact(relative, sizeBytes, expectedDigest) {
+  async verifyReplayArtifact(relative, sizeBytes, expectedDigest, options = {}) {
     const redirect = await fetch(this.url(relative), {
       headers: this.headers(),
       redirect: "manual",
@@ -708,8 +710,13 @@ var PlatformClient = class {
     } catch {
       throw new PlatformError("Stored artifact verification request failed");
     }
-    if (response.status === 404) {
+    if (response.status === 404 || response.status === 403 && options.forbiddenIsAbsent) {
       await response.body?.cancel();
+      if (response.status === 403)
+        appendLog(
+          "info",
+          "upload-replay: storage refused the pending artifact (403); treating it as never written and letting the guarded PUT decide"
+        );
       return { exists: false, url: location };
     }
     if (!response.ok) {
@@ -986,7 +993,7 @@ var TOOLS = [
       { eventName: "Stop", command: GIT_TRACES_CMD("claude") },
       { eventName: "SessionEnd", command: GIT_TRACES_CMD("claude") }
     ],
-    detect: () => isDir(path4.join(os.homedir(), ".claude"))
+    detect: () => isDir(path4.join(homeDir(), ".claude"))
   },
   {
     tool: "cursor",
@@ -1003,7 +1010,7 @@ var TOOLS = [
       { eventName: "stop", command: GIT_TRACES_CMD("cursor") },
       { eventName: "sessionEnd", command: GIT_TRACES_CMD("cursor") }
     ],
-    detect: () => isDir(path4.join(os.homedir(), ".cursor"))
+    detect: () => isDir(path4.join(homeDir(), ".cursor"))
   },
   {
     // opencode has no settings-file hook system (the `experimental.hook` block
@@ -1018,7 +1025,7 @@ var TOOLS = [
     format: "opencode",
     events: [],
     // Events are wired inside the plugin itself; see OPENCODE_PLUGIN_CONTENT.
-    detect: () => isDir(path4.join(os.homedir(), ".local", "share", "opencode")) || isDir(path4.join(os.homedir(), ".config", "opencode"))
+    detect: () => isDir(path4.join(homeDir(), ".local", "share", "opencode")) || isDir(path4.join(homeDir(), ".config", "opencode"))
   },
   {
     // VS Code Copilot Chat. Same "no SessionEnd" constraint as Codex (the
@@ -1058,7 +1065,7 @@ var TOOLS = [
       { eventName: "SessionStart", command: GIT_TRACES_CMD("codex") },
       { eventName: "Stop", command: GIT_TRACES_CMD("codex") }
     ],
-    detect: () => isDir(path4.join(os.homedir(), ".codex"))
+    detect: () => isDir(path4.join(homeDir(), ".codex"))
   }
 ];
 function isDir(p7) {
@@ -1068,8 +1075,11 @@ function isDir(p7) {
     return false;
   }
 }
+function homeDir() {
+  return process.env.HOME || os.homedir();
+}
 function copilotChatDetect() {
-  const home = os.homedir();
+  const home = homeDir();
   const suffix = path4.join("User", "globalStorage", "github.copilot-chat");
   const candidates = [
     path4.join(home, "Library", "Application Support", "Code", suffix),
@@ -2714,22 +2724,76 @@ import { createReadStream } from "fs";
 import fs11 from "fs/promises";
 import path10 from "path";
 
+// src/timing-profile.ts
+var DEFAULT_STAGE_MIN_MS = 250;
+var DEFAULT_LOCK_WAIT_MIN_MS = 1e3;
+var STAGE_MIN_MS_ENV = "HILLCLIMB_TIMING_STAGE_MIN_MS";
+var LOCK_WAIT_MIN_MS_ENV = "HILLCLIMB_TIMING_LOCK_WAIT_MIN_MS";
+function thresholdMs(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const value = Number(raw);
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function shouldLogStage(stage, elapsedMs, status) {
+  if (stage === "lock-wait") {
+    return elapsedMs >= thresholdMs(LOCK_WAIT_MIN_MS_ENV, DEFAULT_LOCK_WAIT_MIN_MS);
+  }
+  return status === "failed" || elapsedMs >= thresholdMs(STAGE_MIN_MS_ENV, DEFAULT_STAGE_MIN_MS);
+}
+var StageProfile = class {
+  constructor(prefix) {
+    this.prefix = prefix;
+  }
+  totals = /* @__PURE__ */ new Map();
+  record(stage, elapsedMs, status) {
+    const totals = this.totals.get(stage) ?? {
+      count: 0,
+      totalMs: 0,
+      maxMs: 0,
+      failed: 0
+    };
+    totals.count++;
+    totals.totalMs += elapsedMs;
+    totals.maxMs = Math.max(totals.maxMs, elapsedMs);
+    if (status === "failed") totals.failed++;
+    this.totals.set(stage, totals);
+  }
+  flush() {
+    if (this.totals.size === 0) return;
+    const entries = [...this.totals].map(([stage, totals]) => {
+      let entry = `${stage}=${totals.totalMs}ms/${totals.count}`;
+      if (totals.count > 1) entry += ` max=${totals.maxMs}ms`;
+      if (totals.failed > 0) entry += ` failed=${totals.failed}`;
+      return entry;
+    });
+    appendLog(
+      "info",
+      `${this.prefix} (stages=${this.totals.size}, ${entries.join(", ")})`
+    );
+    this.totals.clear();
+  }
+};
+
 // src/agent-timing.ts
+var profile = new StageProfile("agent-upload: timing profile");
 function startAgentStage(stage, context = "") {
   const startedAt = Date.now();
   const started = performance.now();
   const suffix = context ? `, ${context}` : "";
-  appendLog(
-    "info",
-    `agent-upload: timing (stage=${stage}, status=started, startedAt=${startedAt}${suffix})`
-  );
   return (status, details) => {
+    const elapsedMs = Math.round(performance.now() - started);
+    profile.record(stage, elapsedMs, status);
+    if (!shouldLogStage(stage, elapsedMs, status)) return;
     appendLog(
       "info",
-      `agent-upload: timing (stage=${stage}, status=${status}, elapsedMs=${Math.round(performance.now() - started)}, finishedAt=${Date.now()}${suffix}${details ? `, ${details}` : ""})`
+      `agent-upload: timing (stage=${stage}, status=${status}, elapsedMs=${elapsedMs}, startedAt=${startedAt}, finishedAt=${Date.now()}${suffix}${details ? `, ${details}` : ""})`
     );
   };
 }
+function flushAgentProfile() {
+  profile.flush();
+}
 async function measureAgentStage(stage, action, context) {
   const finish = startAgentStage(stage, context);
   let status = "failed";
@@ -3193,6 +3257,47 @@ async function detectCodexLineage(childPath) {
   }
 }
 
+// src/git-traces/timing.ts
+import { performance as performance2 } from "perf_hooks";
+var profile2 = new StageProfile("git-traces: capture profile");
+function startCaptureStage(stage, context, startedAt = Date.now()) {
+  const started = performance2.now();
+  return (status, details) => {
+    const elapsedMs = Math.round(performance2.now() - started);
+    profile2.record(stage, elapsedMs, status);
+    if (!shouldLogStage(stage, elapsedMs, status)) return;
+    appendLog(
+      "info",
+      `git-traces: capture timing (${context}, stage=${stage}, status=${status}, elapsedMs=${elapsedMs}, startedAt=${startedAt}, finishedAt=${Date.now()}${details ? `, ${details}` : ""})`
+    );
+  };
+}
+function flushCaptureProfile() {
+  profile2.flush();
+}
+async function timeAsyncCaptureStage(stage, context, run) {
+  const finish = startCaptureStage(stage, context);
+  let status = "failed";
+  try {
+    const result = await run();
+    status = "ok";
+    return result;
+  } finally {
+    finish(status);
+  }
+}
+function timeCaptureStage(repoRoot, stage, run) {
+  const finish = startCaptureStage(stage, `repo=${repoRoot}`);
+  let status = "failed";
+  try {
+    const result = run();
+    status = "ok";
+    return result;
+  } finally {
+    finish(status);
+  }
+}
+
 // src/hook-timing.ts
 var HOOK_RECEIVED_AT_ENV = "HILLCLIMB_HOOK_RECEIVED_AT";
 function pinHookReceivedAt(env, now = Date.now()) {
@@ -3216,6 +3321,8 @@ async function measureHookWork(kind, action) {
     status = "completed";
     return result;
   } finally {
+    flushCaptureProfile();
+    flushAgentProfile();
     appendLog(
       "info",
       `hook-work: kind=${kind} status=${status} finishedAt=${Date.now()} workMs=${Math.round(performance.now() - started)} hookAgeMs=${Math.max(0, Date.now() - receivedAt)}`
@@ -4463,17 +4570,22 @@ async function gitCommonDir(cwd) {
 async function classifyForkCwd(cwd, parentRepoRoot) {
   const resolved = await canonicalPath(cwd);
   const parentRoot = await canonicalPath(parentRepoRoot);
-  if (isAtOrBelow(resolved, parentRoot))
+  const below = isAtOrBelow(resolved, parentRoot);
+  if (below && !hasNestedGitFile(parentRoot, resolved))
     return { kind: "same-tree", repoRoot: parentRoot };
   const toplevel = await gitOut(resolved, ["rev-parse", "--show-toplevel"]);
-  if (!toplevel) return { kind: "unrelated", repoRoot: null };
+  if (!toplevel)
+    return below ? { kind: "same-tree", repoRoot: parentRoot } : { kind: "unrelated", repoRoot: null };
+  const worktreeRoot = await canonicalPath(toplevel);
+  if (worktreeRoot === parentRoot)
+    return { kind: "same-tree", repoRoot: parentRoot };
   const [forkCommon, parentCommon] = await Promise.all([
     gitCommonDir(resolved),
     gitCommonDir(parentRoot)
   ]);
   if (forkCommon && parentCommon && forkCommon === parentCommon)
-    return { kind: "worktree", repoRoot: await canonicalPath(toplevel) };
-  return { kind: "unrelated", repoRoot: null };
+    return { kind: "worktree", repoRoot: worktreeRoot };
+  return below ? { kind: "same-tree", repoRoot: parentRoot } : { kind: "unrelated", repoRoot: null };
 }
 async function discoverCodexForkThreads(params) {
   const nowMs = params.nowMs ?? Date.now();
@@ -14656,46 +14768,6 @@ import fs17 from "fs";
 import os7 from "os";
 import path16 from "path";
 import { createGzip } from "zlib";
-
-// src/git-traces/timing.ts
-import { performance as performance2 } from "perf_hooks";
-function startCaptureStage(stage, context, startedAt = Date.now()) {
-  const started = performance2.now();
-  appendLog(
-    "info",
-    `git-traces: capture timing (${context}, stage=${stage}, status=started, startedAt=${startedAt})`
-  );
-  return (status, details) => {
-    appendLog(
-      "info",
-      `git-traces: capture timing (${context}, stage=${stage}, status=${status}, elapsedMs=${Math.round(performance2.now() - started)}, startedAt=${startedAt}, finishedAt=${Date.now()}${details ? `, ${details}` : ""})`
-    );
-  };
-}
-async function timeAsyncCaptureStage(stage, context, run) {
-  const finish = startCaptureStage(stage, context);
-  let status = "failed";
-  try {
-    const result = await run();
-    status = "ok";
-    return result;
-  } finally {
-    finish(status);
-  }
-}
-function timeCaptureStage(repoRoot, stage, run) {
-  const finish = startCaptureStage(stage, `repo=${repoRoot}`);
-  let status = "failed";
-  try {
-    const result = run();
-    status = "ok";
-    return result;
-  } finally {
-    finish(status);
-  }
-}
-
-// src/git-traces/git-ops.ts
 var DEFAULT_GIT_COMMAND_TIMEOUT_MS = 12e4;
 var DEFAULT_BUNDLE_TIMEOUT_MS = 3e5;
 var FULL_TREE_SCAN_TIMEOUT_MS = 3e5;
@@ -15036,9 +15108,11 @@ function isGitRepo(dir) {
 function stashRetryReason(failure) {
   const status = failure.gitExitStatus;
   if (status !== 1 && status !== 128) return null;
-  if (/Unable to create [^\n]*index\.lock[^\n]*: File exists/.test(
-    failure.gitStderr ?? ""
-  )) {
+  const stderr = failure.gitStderr ?? "";
+  if (/Unable to create [^\n]*index\.lock[^\n]*: File exists/.test(stderr)) {
+    return "index-lock-contention";
+  }
+  if (status === 1 && stderr.trim() === "error: could not write index") {
     return "index-lock-contention";
   }
   if (status === 1 && !failure.gitStderr && !failure.gitStdout) {
@@ -15046,7 +15120,60 @@ function stashRetryReason(failure) {
   }
   return null;
 }
+var PRIVATE_INDEX_ENV = "HILLCLIMB_GIT_PRIVATE_INDEX";
+function withPrivateIndex(repoRoot, run) {
+  if (process.env[PRIVATE_INDEX_ENV] === "0") return run(null);
+  let tmpDir = null;
+  let copy = null;
+  try {
+    const indexPath = path16.resolve(
+      repoRoot,
+      git(repoRoot, ["rev-parse", "--git-path", "index"])
+    );
+    tmpDir = fs17.mkdtempSync(path16.join(os7.tmpdir(), "hillclimb-index-"));
+    copy = path16.join(tmpDir, "index");
+    const fd = fs17.openSync(indexPath, "r");
+    let stat;
+    let data;
+    try {
+      stat = fs17.fstatSync(fd);
+      data = fs17.readFileSync(fd);
+    } finally {
+      fs17.closeSync(fd);
+    }
+    fs17.writeFileSync(copy, data);
+    fs17.utimesSync(copy, stat.atime, stat.mtime);
+  } catch (err) {
+    const missing = err.code === "ENOENT";
+    appendLog(
+      missing ? "info" : "warn",
+      `git-traces: private index unavailable; capturing on the repository index (repo=${repoRoot}, reason=${err instanceof Error ? err.message : String(err)})`
+    );
+    copy = null;
+  }
+  try {
+    return run(copy ? privateIndexEnv(copy) : null);
+  } finally {
+    if (tmpDir) fs17.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+function privateIndexEnv(indexPath) {
+  const existing = Number(process.env.GIT_CONFIG_COUNT);
+  const slot = Number.isInteger(existing) && existing > 0 ? existing : 0;
+  return {
+    GIT_INDEX_FILE: indexPath,
+    GIT_CONFIG_COUNT: String(slot + 1),
+    [`GIT_CONFIG_KEY_${slot}`]: "core.splitIndex",
+    [`GIT_CONFIG_VALUE_${slot}`]: "false"
+  };
+}
 function captureWorkingCommitSha(repoRoot) {
+  return withPrivateIndex(
+    repoRoot,
+    (indexEnv) => captureWorkingCommitShaOnIndex(repoRoot, indexEnv)
+  );
+}
+function captureWorkingCommitShaOnIndex(repoRoot, indexEnv) {
   for (let attempt = 1; ; attempt++) {
     let sha;
     try {
@@ -15057,6 +15184,7 @@ function captureWorkingCommitSha(repoRoot) {
           // Keep the two expected stderr classifications independent of locale.
           gitWithEnv(repoRoot, ["stash", "create"], {
             ...collectorIdentityEnv(),
+            ...indexEnv,
             LC_ALL: "C"
           })
         )
@@ -15069,7 +15197,10 @@ function captureWorkingCommitSha(repoRoot) {
           "info",
           `git-traces: stash create unavailable (repo=${repoRoot}, reason=unborn-head); capturing index tree`
         );
-        const tree = git(repoRoot, ["write-tree"]);
+        const tree = gitWithEnv(repoRoot, ["write-tree"], {
+          ...process.env,
+          ...indexEnv
+        });
         return commitTree(repoRoot, tree, "empty baseline");
       }
       const retryReason = stashRetryReason(failure);
@@ -15771,7 +15902,10 @@ function buildBaselineMetadata(repoRoot, sessionId, tool, baselineSha, cliVersio
   const headSha = safeGit(repoRoot, ["rev-parse", "HEAD"]) ?? "unknown";
   const branch = safeGit(repoRoot, ["rev-parse", "--abbrev-ref", "HEAD"]) ?? null;
   const remoteUrl = safeGit(repoRoot, ["config", "--get", "remote.origin.url"]) ?? null;
-  const statusRaw = safeGitBuffer(repoRoot, ["status", "--porcelain=v1", "-z"]) ?? Buffer.alloc(0);
+  const statusRaw = withPrivateIndex(
+    repoRoot,
+    (indexEnv) => safeGitBuffer(repoRoot, ["status", "--porcelain=v1", "-z"], indexEnv)
+  ) ?? Buffer.alloc(0);
   const dirtyFiles = parseDirtyFilesFromStatus(statusRaw);
   const authorName = safeGit(repoRoot, ["config", "user.name"]) ?? "";
   const authorEmail = safeGit(repoRoot, ["config", "user.email"]) ?? "";
@@ -15920,9 +16054,13 @@ function safeGit(repoRoot, args) {
     return null;
   }
 }
-function safeGitBuffer(repoRoot, args) {
+function safeGitBuffer(repoRoot, args, env = null) {
   try {
-    return gitBuffer(repoRoot, args);
+    return gitBuffer(
+      repoRoot,
+      args,
+      env ? { env: { ...process.env, ...env } } : {}
+    );
   } catch (err) {
     if (isGitTimeoutError(err)) {
       appendLog(
@@ -16831,7 +16969,7 @@ async function uploadArtifact(client, contributionId, filename, mimeType, buffer
 }
 
 // package.json
-var version = "0.9.1";
+var version = "0.9.3";
 
 // src/version.ts
 var CLI_VERSION = version;
@@ -16972,8 +17110,14 @@ function isPhantomClaudeHook(payload, toolOverride) {
 }
 var MAX_FORK_SWEEP_THREADS = 8;
 async function runUploadInner(payload, options = {}) {
-  const outcome = await runUploadForSession(payload, options);
-  const settled = outcome === "uploaded" || outcome === "unchanged" || outcome === "skipped";
+  let outcome;
+  let failure;
+  try {
+    outcome = await runUploadForSession(payload, options);
+  } catch (err) {
+    failure = err;
+  }
+  const settled = failure !== void 0 || outcome === "uploaded" || outcome === "unchanged" || outcome === "skipped";
   if (!options.sweptFrom && payload.tool === "codex" && settled) {
     await sweepCodexForkTranscripts(payload);
   }
@@ -16983,6 +17127,7 @@ async function runUploadInner(payload, options = {}) {
   if (!options.sweptFrom && settled) {
     await sweepStrandedAgentUploads(resolveHookSessionId(payload));
   }
+  if (failure !== void 0) throw failure;
   return outcome;
 }
 var MAX_SUBAGENT_SWEEP = 32;

package/package.json

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