@posthog/agent 2.3.510 → 2.3.513

package/dist/server/agent-server.js

@@ -513,7 +513,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os7 = __require("os");
+    var os8 = __require("os");
     var tty = __require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -561,7 +561,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os7.release().split(".");
+        const osRelease = os8.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -809,10 +809,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log = debug_1.default("@kwsites/file-exists");
-    function check(path16, isFile2, isDirectory) {
-      log(`checking %s`, path16);
+    function check(path17, isFile2, isDirectory) {
+      log(`checking %s`, path17);
       try {
-        const stat4 = fs_1.statSync(path16);
+        const stat4 = fs_1.statSync(path17);
         if (stat4.isFile() && isFile2) {
           log(`[OK] path represents a file`);
           return true;
@@ -832,8 +832,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path16, type = exports2.READABLE) {
-      return check(path16, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
+    function exists2(path17, type = exports2.READABLE) {
+      return check(path17, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
     }
     exports2.exists = exists2;
     exports2.FILE = 1;
@@ -929,11 +929,11 @@ var require_tree_sitter = __commonJS({
               throw toThrow;
             };
             var scriptDirectory = "";
-            function locateFile(path16) {
+            function locateFile(path17) {
               if (Module["locateFile"]) {
-                return Module["locateFile"](path16, scriptDirectory);
+                return Module["locateFile"](path17, scriptDirectory);
               }
-              return scriptDirectory + path16;
+              return scriptDirectory + path17;
             }
             var readAsync, readBinary;
             if (ENVIRONMENT_IS_NODE) {
@@ -3454,8 +3454,8 @@ var require_tree_sitter = __commonJS({
                 } else {
                   const url = input;
                   if (typeof process !== "undefined" && process.versions && process.versions.node) {
-                    const fs13 = __require("fs");
-                    bytes = Promise.resolve(fs13.readFileSync(url));
+                    const fs14 = __require("fs");
+                    bytes = Promise.resolve(fs14.readFileSync(url));
                   } else {
                     bytes = fetch(url).then((response) => response.arrayBuffer().then((buffer) => {
                       if (response.ok) {
@@ -3785,7 +3785,7 @@ ${JSON.stringify(symbolNames, null, 2)}`);
 
 // src/server/agent-server.ts
 import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import { basename as basename2, join as join11 } from "path";
+import { basename as basename2, join as join12 } from "path";
 import { pathToFileURL } from "url";
 import {
   ClientSideConnection as ClientSideConnection2,
@@ -3835,8 +3835,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path16) {
-  return path16 instanceof String && cache.has(path16);
+function isPathSpec(path17) {
+  return path17 instanceof String && cache.has(path17);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -3925,8 +3925,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path16) {
-  return (0, import_file_exists.exists)(path16, import_file_exists.FOLDER);
+function folderExists(path17) {
+  return (0, import_file_exists.exists)(path17, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -4330,8 +4330,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path16) {
-      return /^\.(git)?$/.test(path16.trim());
+    parser(path17) {
+      return /^\.(git)?$/.test(path17.trim());
     }
   };
 }
@@ -4765,11 +4765,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path16, line, preview] = input.split(NULL);
-    paths.add(path16);
-    (results[path16] = results[path16] || []).push({
+    const [path17, line, preview] = input.split(NULL);
+    paths.add(path17);
+    (results[path17] = results[path17] || []).push({
       line: asNumber(line),
-      path: path16,
+      path: path17,
       preview
     });
   });
@@ -5534,14 +5534,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path16, text2) {
+function parseInit(bare, path17, text2) {
   const response = String(text2).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path16, false, result[1]);
+    return new InitSummary(bare, path17, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path16, true, result[1]);
+    return new InitSummary(bare, path17, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -5552,7 +5552,7 @@ function parseInit(bare, path16, text2) {
       break;
     }
   }
-  return new InitSummary(bare, path16, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path17, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -5561,9 +5561,9 @@ var init_InitSummary = __esm({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path16, existing, gitDir) {
+      constructor(bare, path17, existing, gitDir) {
         this.bare = bare;
-        this.path = path16;
+        this.path = path17;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -5575,7 +5575,7 @@ var init_InitSummary = __esm({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path16, customArgs) {
+function initTask(bare = false, path17, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -5584,7 +5584,7 @@ function initTask(bare = false, path16, customArgs) {
     commands,
     format: "utf-8",
     parser(text2) {
-      return parseInit(commands.includes("--bare"), path16, text2);
+      return parseInit(commands.includes("--bare"), path17, text2);
     }
   };
 }
@@ -6400,12 +6400,12 @@ var init_FileStatusSummary = __esm({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path16, index, working_dir) {
-        this.path = path16;
+      constructor(path17, index, working_dir) {
+        this.path = path17;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path16) || [null, path16, path16];
+          const detail = fromPathRegex.exec(path17) || [null, path17, path17];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -6436,14 +6436,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path16) {
+  function data(index, workingDir, path17) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path16);
+      handler(result, path17);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path16, index, workingDir));
+      result.files.push(new FileStatusSummary(path17, index, workingDir));
     }
   }
 }
@@ -6756,9 +6756,9 @@ var init_simple_git_api = __esm({
           next
         );
       }
-      hashObject(path16, write) {
+      hashObject(path17, write) {
         return this._runTask(
-          hashObjectTask(path16, write === true),
+          hashObjectTask(path17, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -7111,8 +7111,8 @@ var init_branch = __esm({
   }
 });
 function toPath(input) {
-  const path16 = input.trim().replace(/^["']|["']$/g, "");
-  return path16 && normalize(path16);
+  const path17 = input.trim().replace(/^["']|["']$/g, "");
+  return path17 && normalize(path17);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
@@ -7426,8 +7426,8 @@ __export(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path16) {
-  return subModuleTask(["add", repo, path16]);
+function addSubModuleTask(repo, path17) {
+  return subModuleTask(["add", repo, path17]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -7757,8 +7757,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path16, then) {
-      return this._runTask(addSubModuleTask2(repo, path16), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path17, then) {
+      return this._runTask(addSubModuleTask2(repo, path17), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args2, then) {
       return this._runTask(
@@ -8599,7 +8599,7 @@ import { z as z4 } from "zod";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.510",
+  version: "2.3.513",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -9035,9 +9035,9 @@ function nodeWritableToWebWritable(nodeStream) {
 
 // src/adapters/claude/claude-agent.ts
 import { randomUUID } from "crypto";
-import * as fs8 from "fs";
-import * as os4 from "os";
-import * as path10 from "path";
+import * as fs9 from "fs";
+import * as os5 from "os";
+import * as path11 from "path";
 import {
   RequestError as RequestError2
 } from "@agentclientprotocol/sdk";
@@ -13449,8 +13449,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path16, oldText, newText) {
-    this.items.push({ type: "diff", path: path16, oldText, newText });
+  diff(path17, oldText, newText) {
+    this.items.push({ type: "diff", path: path17, oldText, newText });
     return this;
   }
   build() {
@@ -15825,6 +15825,31 @@ function getAvailableSlashCommands(commands) {
 }
 
 // src/adapters/claude/session/mcp-config.ts
+import * as fs6 from "fs";
+import * as os2 from "os";
+import * as path8 from "path";
+function loadUserClaudeJsonMcpServers(cwd, logger, homeDir = os2.homedir()) {
+  const claudeJsonPath = path8.join(homeDir, ".claude.json");
+  let raw;
+  try {
+    raw = fs6.readFileSync(claudeJsonPath, "utf8");
+  } catch {
+    return {};
+  }
+  let cfg;
+  try {
+    cfg = JSON.parse(raw);
+  } catch (err2) {
+    logger?.warn("Failed to parse ~/.claude.json", {
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+    return {};
+  }
+  const topLevel = cfg.mcpServers && typeof cfg.mcpServers === "object" ? cfg.mcpServers : {};
+  const project = cfg.projects?.[cwd];
+  const projectScoped = project?.mcpServers && typeof project.mcpServers === "object" ? project.mcpServers : {};
+  return { ...topLevel, ...projectScoped };
+}
 function parseMcpServers(params) {
   const mcpServers = {};
   if (!Array.isArray(params.mcpServers)) {
@@ -15958,9 +15983,9 @@ function resolveModelPreference(preference, options) {
 
 // src/adapters/claude/session/options.ts
 import { spawn as spawn2 } from "child_process";
-import * as fs6 from "fs";
-import * as os2 from "os";
-import * as path8 from "path";
+import * as fs7 from "fs";
+import * as os3 from "os";
+import * as path9 from "path";
 
 // src/adapters/claude/session/instructions.ts
 var BRANCH_NAMING = `
@@ -16011,8 +16036,9 @@ function buildSystemPrompt(customPrompt) {
   }
   return defaultPrompt;
 }
-function buildMcpServers(userServers, acpServers) {
+function buildMcpServers(userServers, acpServers, projectScopedServers) {
   return {
+    ...projectScopedServers,
     ...userServers || {},
     ...acpServers
   };
@@ -16161,12 +16187,12 @@ function buildSpawnWrapper(sessionId, onProcessSpawned, onProcessExited, logger)
   };
 }
 function ensureLocalSettings(cwd) {
-  const claudeDir = path8.join(cwd, ".claude");
-  const localSettingsPath = path8.join(claudeDir, "settings.local.json");
+  const claudeDir = path9.join(cwd, ".claude");
+  const localSettingsPath = path9.join(claudeDir, "settings.local.json");
   try {
-    if (!fs6.existsSync(localSettingsPath)) {
-      fs6.mkdirSync(claudeDir, { recursive: true });
-      fs6.writeFileSync(localSettingsPath, "{}\n", { flag: "wx" });
+    if (!fs7.existsSync(localSettingsPath)) {
+      fs7.mkdirSync(claudeDir, { recursive: true });
+      fs7.writeFileSync(localSettingsPath, "{}\n", { flag: "wx" });
     }
   } catch {
   }
@@ -16196,7 +16222,8 @@ function buildSessionOptions(params) {
     },
     mcpServers: buildMcpServers(
       params.userProvidedOptions?.mcpServers,
-      params.mcpServers
+      params.mcpServers,
+      loadUserClaudeJsonMcpServers(params.cwd, params.logger)
     ),
     env: buildEnvironment(),
     hooks: buildHooks(
@@ -16241,18 +16268,18 @@ function buildSessionOptions(params) {
   return options;
 }
 function clearStatsigCache() {
-  const statsigPath = path8.join(
-    process.env.CLAUDE_CONFIG_DIR || path8.join(os2.homedir(), ".claude"),
+  const statsigPath = path9.join(
+    process.env.CLAUDE_CONFIG_DIR || path9.join(os3.homedir(), ".claude"),
     "statsig"
   );
-  fs6.rm(statsigPath, { recursive: true, force: true }, () => {
+  fs7.rm(statsigPath, { recursive: true, force: true }, () => {
   });
 }
 
 // src/adapters/claude/session/settings.ts
-import * as fs7 from "fs";
-import * as os3 from "os";
-import * as path9 from "path";
+import * as fs8 from "fs";
+import * as os4 from "os";
+import * as path10 from "path";
 import { minimatch } from "minimatch";
 
 // src/utils/async-mutex.ts
@@ -16333,13 +16360,13 @@ function parseRule(rule) {
 function normalizePath(filePath, cwd) {
   let resolved = filePath;
   if (resolved.startsWith("~/")) {
-    resolved = path9.join(os3.homedir(), resolved.slice(2));
+    resolved = path10.join(os4.homedir(), resolved.slice(2));
   } else if (resolved.startsWith("./")) {
-    resolved = path9.join(cwd, resolved.slice(2));
-  } else if (!path9.isAbsolute(resolved)) {
-    resolved = path9.join(cwd, resolved);
+    resolved = path10.join(cwd, resolved.slice(2));
+  } else if (!path10.isAbsolute(resolved)) {
+    resolved = path10.join(cwd, resolved);
   }
-  return path9.normalize(resolved).replace(/\\/g, "/");
+  return path10.normalize(resolved).replace(/\\/g, "/");
 }
 function matchesGlob(pattern, filePath, cwd) {
   const normalizedPattern = normalizePath(pattern, cwd);
@@ -16386,11 +16413,11 @@ function formatRule(rule) {
 }
 async function writeFileAtomic(filePath, data) {
   const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await fs7.promises.writeFile(tmpPath, data);
+  await fs8.promises.writeFile(tmpPath, data);
   try {
-    await fs7.promises.rename(tmpPath, filePath);
+    await fs8.promises.rename(tmpPath, filePath);
   } catch (error) {
-    await fs7.promises.rm(tmpPath, { force: true });
+    await fs8.promises.rm(tmpPath, { force: true });
     throw error;
   }
 }
@@ -16399,7 +16426,7 @@ async function loadSettingsFile(filePath) {
     return {};
   }
   try {
-    const content = await fs7.promises.readFile(filePath, "utf-8");
+    const content = await fs8.promises.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -16414,7 +16441,7 @@ async function loadSettingsFile(filePath) {
 }
 async function readSettingsFileForUpdate(filePath) {
   try {
-    const content = await fs7.promises.readFile(filePath, "utf-8");
+    const content = await fs8.promises.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -16460,11 +16487,11 @@ var SettingsManager = class {
     return this.initPromise;
   }
   getUserSettingsPath() {
-    const configDir = process.env.CLAUDE_CONFIG_DIR || path9.join(os3.homedir(), ".claude");
-    return path9.join(configDir, "settings.json");
+    const configDir = process.env.CLAUDE_CONFIG_DIR || path10.join(os4.homedir(), ".claude");
+    return path10.join(configDir, "settings.json");
   }
   getProjectSettingsPath() {
-    return path9.join(this.cwd, ".claude", "settings.json");
+    return path10.join(this.cwd, ".claude", "settings.json");
   }
   /**
    * Local settings are anchored to the primary worktree so every worktree of
@@ -16472,7 +16499,7 @@ var SettingsManager = class {
    * avoids re-prompting for the same permission in every worktree.
    */
   getLocalSettingsPath() {
-    return path9.join(this.repoRoot, ".claude", "settings.local.json");
+    return path10.join(this.repoRoot, ".claude", "settings.local.json");
   }
   async loadAllSettings() {
     this.repoRoot = await resolveMainRepoPath(this.cwd);
@@ -16599,7 +16626,7 @@ var SettingsManager = class {
       }
       permissions.allow = Array.from(current2);
       const next = { ...existing, permissions };
-      await fs7.promises.mkdir(path9.dirname(filePath), { recursive: true });
+      await fs8.promises.mkdir(path10.dirname(filePath), { recursive: true });
       await writeFileAtomic(filePath, `${JSON.stringify(next, null, 2)}
 `);
       this.localSettings = next;
@@ -16632,7 +16659,7 @@ var SettingsManager = class {
         ...existing,
         posthogApprovedExecTools: Array.from(current2)
       };
-      await fs7.promises.mkdir(path9.dirname(filePath), { recursive: true });
+      await fs8.promises.mkdir(path10.dirname(filePath), { recursive: true });
       await writeFileAtomic(filePath, `${JSON.stringify(next, null, 2)}
 `);
       this.localSettings = next;
@@ -16738,7 +16765,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     };
   }
   async newSession(params) {
-    if (fs8.existsSync(path10.resolve(os4.homedir(), ".claude.json.backup")) && !fs8.existsSync(path10.resolve(os4.homedir(), ".claude.json"))) {
+    if (fs9.existsSync(path11.resolve(os5.homedir(), ".claude.json.backup")) && !fs9.existsSync(path11.resolve(os5.homedir(), ".claude.json"))) {
       throw RequestError2.authRequired();
     }
     const response = await this.createSession(params, {
@@ -17981,9 +18008,9 @@ function resetUsage(state) {
 }
 
 // src/adapters/codex/settings.ts
-import * as fs9 from "fs";
-import * as os5 from "os";
-import * as path11 from "path";
+import * as fs10 from "fs";
+import * as os6 from "os";
+import * as path12 from "path";
 var CodexSettingsManager = class {
   cwd;
   settings = { mcpServerNames: [] };
@@ -17994,12 +18021,12 @@ var CodexSettingsManager = class {
   async initialize() {
   }
   getConfigPath() {
-    return path11.join(os5.homedir(), ".codex", "config.toml");
+    return path12.join(os6.homedir(), ".codex", "config.toml");
   }
   loadSettings() {
     const configPath = this.getConfigPath();
     try {
-      const content = fs9.readFileSync(configPath, "utf-8");
+      const content = fs10.readFileSync(configPath, "utf-8");
       this.settings = parseCodexToml(content, this.cwd);
     } catch {
       this.settings = { mcpServerNames: [] };
@@ -18770,18 +18797,18 @@ function createCodexConnection(config) {
 // src/handoff-checkpoint.ts
 import { mkdtemp as mkdtemp2, readFile as readFile4, rm as rm4, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname6, join as join9 } from "path";
+import { dirname as dirname6, join as join10 } from "path";
 
 // ../git/dist/handoff.js
 import { spawn as spawn4 } from "child_process";
 import { copyFile, mkdtemp, readFile as readFile3, rm as rm3, stat as stat3 } from "fs/promises";
 import { tmpdir } from "os";
-import path13 from "path";
+import path14 from "path";
 
 // ../git/dist/sagas/checkpoint.js
 import { randomUUID as randomUUID2 } from "crypto";
-import * as fs10 from "fs/promises";
-import * as path12 from "path";
+import * as fs11 from "fs/promises";
+import * as path13 from "path";
 
 // ../shared/dist/index.js
 var CLOUD_PROMPT_PREFIX = "__twig_cloud_prompt_v1__:";
@@ -19054,12 +19081,12 @@ async function getGitBusyState(git) {
   const toplevel = (await git.raw(["rev-parse", "--show-toplevel"])).trim();
   const resolveGitPath = async (gitPath) => {
     const relative = (await git.raw(["rev-parse", "--git-path", gitPath])).trim();
-    return path12.isAbsolute(relative) ? relative : path12.resolve(toplevel, relative);
+    return path13.isAbsolute(relative) ? relative : path13.resolve(toplevel, relative);
   };
   const pathExists = async (gitPath) => {
     const resolved = await resolveGitPath(gitPath);
     try {
-      await fs10.access(resolved);
+      await fs11.access(resolved);
       return true;
     } catch {
       return false;
@@ -19068,7 +19095,7 @@ async function getGitBusyState(git) {
   const dirExists = async (gitPath) => {
     const resolved = await resolveGitPath(gitPath);
     try {
-      const stat4 = await fs10.stat(resolved);
+      const stat4 = await fs11.stat(resolved);
       return stat4.isDirectory();
     } catch {
       return false;
@@ -19088,6 +19115,7 @@ async function getGitBusyState(git) {
   }
   return { busy: false };
 }
+var MAX_WORKTREE_FILE_BYTES = 1024 * 1024;
 async function createWorktreeTree(git, baseDir, head) {
   const { tempGit, tempIndexPath } = await createTempIndexGit(git, baseDir, "checkpoint-worktree");
   try {
@@ -19097,13 +19125,85 @@ async function createWorktreeTree(git, baseDir, head) {
       await tempGit.raw(["read-tree", "--empty"]);
     }
     await tempGit.raw(["add", "-A", "--", "."]);
+    await reconcileLargeBlobs(tempGit, head, MAX_WORKTREE_FILE_BYTES);
     const treeHash = await tempGit.raw(["write-tree"]);
     return treeHash.trim();
   } finally {
-    await fs10.rm(tempIndexPath, { force: true }).catch(() => {
+    await fs11.rm(tempIndexPath, { force: true }).catch(() => {
     });
   }
 }
+async function reconcileLargeBlobs(tempGit, head, maxBytes) {
+  const intermediateTree = (await tempGit.raw(["write-tree"])).trim();
+  const largePaths = await listLargeBlobPaths(tempGit, intermediateTree, maxBytes);
+  if (largePaths.length === 0)
+    return;
+  const headEntries = head ? await readHeadBlobEntries(tempGit, head, largePaths) : /* @__PURE__ */ new Map();
+  for (const filePath of largePaths) {
+    const headEntry = headEntries.get(filePath);
+    if (headEntry) {
+      await tempGit.raw([
+        "update-index",
+        "--cacheinfo",
+        `${headEntry.mode},${headEntry.hash},${filePath}`
+      ]);
+    } else {
+      await tempGit.raw(["update-index", "--force-remove", filePath]).catch(() => {
+      });
+    }
+  }
+}
+async function listLargeBlobPaths(tempGit, tree, maxBytes) {
+  const output = await tempGit.raw(["ls-tree", "-r", "-l", tree]);
+  const result = [];
+  for (const line of output.split("\n")) {
+    if (!line)
+      continue;
+    const tabIndex = line.indexOf("	");
+    if (tabIndex < 0)
+      continue;
+    const meta = line.slice(0, tabIndex);
+    const filePath = line.slice(tabIndex + 1);
+    const parts2 = meta.split(/\s+/);
+    if (parts2.length < 4)
+      continue;
+    const [, type, , sizeStr] = parts2;
+    if (type !== "blob")
+      continue;
+    if (sizeStr === "-")
+      continue;
+    const size = Number.parseInt(sizeStr, 10);
+    if (Number.isFinite(size) && size > maxBytes) {
+      result.push(filePath);
+    }
+  }
+  return result;
+}
+async function readHeadBlobEntries(tempGit, head, paths) {
+  const result = /* @__PURE__ */ new Map();
+  const CHUNK_SIZE = 100;
+  for (let i2 = 0; i2 < paths.length; i2 += CHUNK_SIZE) {
+    const chunk = paths.slice(i2, i2 + CHUNK_SIZE);
+    const output = await tempGit.raw(["ls-tree", "-r", head, "--", ...chunk]).catch(() => "");
+    for (const line of output.split("\n")) {
+      if (!line)
+        continue;
+      const tabIndex = line.indexOf("	");
+      if (tabIndex < 0)
+        continue;
+      const meta = line.slice(0, tabIndex);
+      const filePath = line.slice(tabIndex + 1);
+      const parts2 = meta.split(/\s+/);
+      if (parts2.length < 3)
+        continue;
+      const [mode, type, hash] = parts2;
+      if (type !== "blob")
+        continue;
+      result.set(filePath, { mode, hash });
+    }
+  }
+  return result;
+}
 async function createMetaTree(git, baseDir, indexTree, worktreeTree) {
   const { tempGit, tempIndexPath } = await createTempIndexGit(git, baseDir, "checkpoint-meta");
   try {
@@ -19127,7 +19227,7 @@ async function createMetaTree(git, baseDir, indexTree, worktreeTree) {
     const metaTree = await tempGit.raw(["write-tree"]);
     return metaTree.trim();
   } finally {
-    await fs10.rm(tempIndexPath, { force: true }).catch(() => {
+    await fs11.rm(tempIndexPath, { force: true }).catch(() => {
     });
   }
 }
@@ -19144,12 +19244,12 @@ function formatCheckpointMessage(meta) {
 async function getGitCommonDir(git, baseDir) {
   const raw = await git.raw(["rev-parse", "--git-common-dir"]);
   const dir = raw.trim() || ".git";
-  return path12.isAbsolute(dir) ? dir : path12.resolve(baseDir, dir);
+  return path13.isAbsolute(dir) ? dir : path13.resolve(baseDir, dir);
 }
 async function createTempIndexGit(git, baseDir, label) {
-  const tmpDir = path12.join(await getGitCommonDir(git, baseDir), "posthog-code-tmp");
-  await fs10.mkdir(tmpDir, { recursive: true });
-  const tempIndexPath = path12.join(tmpDir, `${label}-${Date.now()}-${randomUUID2()}`);
+  const tmpDir = path13.join(await getGitCommonDir(git, baseDir), "posthog-code-tmp");
+  await fs11.mkdir(tmpDir, { recursive: true });
+  const tempIndexPath = path13.join(tmpDir, `${label}-${Date.now()}-${randomUUID2()}`);
   const tempGit = createGitClient(baseDir).env({
     ...process.env,
     GIT_INDEX_FILE: tempIndexPath
@@ -19176,6 +19276,7 @@ async function deleteCheckpoint(git, checkpointId) {
 // ../git/dist/handoff.js
 var HANDOFF_HEAD_REF_PREFIX = "refs/posthog-code-handoff/head/";
 var CHECKPOINT_REF_PREFIX2 = "refs/posthog-code-checkpoint/";
+var MAX_HANDOFF_FILE_BYTES = 1024 * 1024;
 var GitHandoffTracker = class {
   repositoryPath;
   logger;
@@ -19183,7 +19284,7 @@ var GitHandoffTracker = class {
     this.repositoryPath = config.repositoryPath;
     this.logger = config.logger;
   }
-  async captureForHandoff(_localGitState) {
+  async captureForHandoff(localGitState) {
     const captureSaga = new CaptureCheckpointSaga(this.logger);
     const result = await captureSaga.run({ baseDir: this.repositoryPath });
     if (!result.success) {
@@ -19193,17 +19294,20 @@ var GitHandoffTracker = class {
     const git = createGitClient(this.repositoryPath);
     const tempDir = await this.createTempDir(checkpoint.checkpointId);
     const checkpointRef = `${CHECKPOINT_REF_PREFIX2}${checkpoint.checkpointId}`;
-    const packRefs = [
-      checkpoint.head,
-      checkpoint.indexTree,
-      checkpoint.worktreeTree
-    ].filter((ref) => !!ref);
-    const headRef = checkpoint.head ? `${HANDOFF_HEAD_REF_PREFIX}${checkpoint.checkpointId}` : void 0;
-    const packPrefix = path13.join(tempDir, checkpoint.checkpointId);
     try {
+      const reconciledIndex = await this.reconcileHandoffIndex(git, checkpoint.head, checkpoint.indexTree, tempDir, checkpoint.checkpointId);
+      const packBaseline = localGitState?.upstreamHead ?? null;
+      const packRefs = [
+        checkpoint.head,
+        reconciledIndex.indexTree,
+        checkpoint.worktreeTree,
+        packBaseline ? `^${packBaseline}` : null
+      ].filter((ref) => !!ref);
+      const headRef = checkpoint.head ? `${HANDOFF_HEAD_REF_PREFIX}${checkpoint.checkpointId}` : void 0;
+      const packPrefix = path14.join(tempDir, checkpoint.checkpointId);
       const [headPack, indexFile, tracking] = await Promise.all([
         this.captureObjectPack(packPrefix, packRefs),
-        this.copyIndexFile(git, checkpoint.checkpointId, tempDir),
+        this.statFileArtifact(reconciledIndex.indexFilePath),
         getTrackingMetadata(git, checkpoint.branch)
       ]);
       return {
@@ -19214,7 +19318,7 @@ var GitHandoffTracker = class {
           headRef,
           head: checkpoint.head,
           branch: checkpoint.branch,
-          indexTree: checkpoint.indexTree,
+          indexTree: reconciledIndex.indexTree,
           worktreeTree: checkpoint.worktreeTree,
           timestamp: checkpoint.timestamp,
           upstreamRemote: tracking.upstreamRemote,
@@ -19234,6 +19338,7 @@ var GitHandoffTracker = class {
     const { checkpoint, headPackPath, indexPath, localGitState, onDivergedBranch } = input;
     const git = createGitClient(this.repositoryPath);
     if (headPackPath) {
+      await this.ensureBaselineForApply(git, checkpoint, localGitState);
       await this.unpackPackFile(headPackPath);
     }
     if (checkpoint.branch && checkpoint.head) {
@@ -19272,14 +19377,89 @@ var GitHandoffTracker = class {
     });
     return { path: packPath, rawBytes };
   }
-  async copyIndexFile(git, checkpointId, tempDir) {
-    const indexPath = await this.getGitPath(git, "index");
-    const copiedIndexPath = path13.join(tempDir, `${checkpointId}.index`);
-    await copyFile(indexPath, copiedIndexPath);
-    return {
-      path: copiedIndexPath,
-      rawBytes: await this.getFileSize(copiedIndexPath)
-    };
+  async reconcileHandoffIndex(git, head, indexTree, tempDir, checkpointId) {
+    const realIndexPath = await this.getGitPath(git, "index");
+    const tempIndexPath = path14.join(tempDir, `${checkpointId}.index`);
+    await copyFile(realIndexPath, tempIndexPath);
+    const largePaths = await this.listLargeBlobsInTree(indexTree, MAX_HANDOFF_FILE_BYTES);
+    if (largePaths.length === 0) {
+      return { indexTree, indexFilePath: tempIndexPath };
+    }
+    const headBlobs = head ? await this.readHeadBlobsForPaths(head, largePaths) : /* @__PURE__ */ new Map();
+    const env = { ...process.env, GIT_INDEX_FILE: tempIndexPath };
+    for (const filePath of largePaths) {
+      const headBlob = headBlobs.get(filePath);
+      if (headBlob) {
+        await this.runGitWithEnv(env, [
+          "update-index",
+          "--cacheinfo",
+          `${headBlob.mode},${headBlob.hash},${filePath}`
+        ]);
+      } else {
+        await this.runGitWithEnv(env, [
+          "update-index",
+          "--force-remove",
+          filePath
+        ]).catch(() => {
+        });
+      }
+    }
+    const reconciledTree = (await this.runGitWithEnv(env, ["write-tree"])).trim();
+    return { indexTree: reconciledTree, indexFilePath: tempIndexPath };
+  }
+  async listLargeBlobsInTree(tree, maxBytes) {
+    const { stdout } = await this.runGitProcess(["ls-tree", "-r", "-l", tree], "");
+    const result = [];
+    for (const line of stdout.split("\n")) {
+      if (!line)
+        continue;
+      const tabIndex = line.indexOf("	");
+      if (tabIndex < 0)
+        continue;
+      const meta = line.slice(0, tabIndex);
+      const filePath = line.slice(tabIndex + 1);
+      const parts2 = meta.split(/\s+/);
+      if (parts2.length < 4)
+        continue;
+      const [, type, , sizeStr] = parts2;
+      if (type !== "blob")
+        continue;
+      if (sizeStr === "-")
+        continue;
+      const size = Number.parseInt(sizeStr, 10);
+      if (Number.isFinite(size) && size > maxBytes) {
+        result.push(filePath);
+      }
+    }
+    return result;
+  }
+  async readHeadBlobsForPaths(head, paths) {
+    const result = /* @__PURE__ */ new Map();
+    const CHUNK_SIZE = 100;
+    for (let i2 = 0; i2 < paths.length; i2 += CHUNK_SIZE) {
+      const chunk = paths.slice(i2, i2 + CHUNK_SIZE);
+      const { stdout } = await this.runGitProcess(["ls-tree", "-r", head, "--", ...chunk], "").catch(() => ({ stdout: "", stderr: "" }));
+      for (const line of stdout.split("\n")) {
+        if (!line)
+          continue;
+        const tabIndex = line.indexOf("	");
+        if (tabIndex < 0)
+          continue;
+        const meta = line.slice(0, tabIndex);
+        const filePath = line.slice(tabIndex + 1);
+        const parts2 = meta.split(/\s+/);
+        if (parts2.length < 3)
+          continue;
+        const [mode, type, hash] = parts2;
+        if (type !== "blob")
+          continue;
+        result.set(filePath, { mode, hash });
+      }
+    }
+    return result;
+  }
+  async statFileArtifact(filePath) {
+    return { path: filePath, rawBytes: await this.getFileSize(filePath) };
   }
   async restoreIndexFile(git, indexPath) {
     const gitIndexPath = await this.getGitPath(git, "index");
@@ -19307,6 +19487,20 @@ var GitHandoffTracker = class {
   shouldRestoreTracking(branchStatus2, localGitState, tracking) {
     return branchStatus2.kind === "missing" || !hasTrackingConfig(localGitState) && (tracking.upstreamRemote !== null || tracking.upstreamMergeRef !== null);
   }
+  async ensureBaselineForApply(git, checkpoint, localGitState) {
+    const tracking = this.getPreferredTracking(localGitState, checkpoint);
+    if (!tracking.upstreamRemote || !tracking.upstreamMergeRef)
+      return;
+    await this.ensureRemoteForTracking(git, tracking).catch(() => {
+    });
+    await git.raw(["fetch", tracking.upstreamRemote, tracking.upstreamMergeRef]).catch((err2) => {
+      this.logger?.error("Handoff baseline fetch failed; if the pack excludes commits the receiver does not already have, the subsequent unpack/read-tree will fail with an object-missing error", {
+        err: String(err2),
+        remote: tracking.upstreamRemote,
+        ref: tracking.upstreamMergeRef
+      });
+    });
+  }
   async ensureRemoteForTracking(git, tracking) {
     if (!tracking.upstreamRemote || !tracking.remoteUrl)
       return;
@@ -19407,7 +19601,7 @@ var GitHandoffTracker = class {
   async getGitPath(git, gitPath) {
     const raw = await git.raw(["rev-parse", "--git-path", gitPath]);
     const resolved = raw.trim();
-    return path13.isAbsolute(resolved) ? resolved : path13.resolve(this.repositoryPath, resolved);
+    return path14.isAbsolute(resolved) ? resolved : path14.resolve(this.repositoryPath, resolved);
   }
   async getFileSize(filePath) {
     return (await stat3(filePath)).size;
@@ -19443,6 +19637,31 @@ var GitHandoffTracker = class {
       });
     });
   }
+  async runGitWithEnv(env, args2) {
+    return new Promise((resolve7, reject) => {
+      const child = spawn4("git", args2, {
+        cwd: this.repositoryPath,
+        stdio: ["ignore", "pipe", "pipe"],
+        env
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("error", reject);
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve7(stdout);
+          return;
+        }
+        reject(new Error(stderr || `git ${args2.join(" ")} failed with code ${code}`));
+      });
+    });
+  }
   runGitProcess(args2, input) {
     return new Promise((resolve7, reject) => {
       const child = spawn4("git", args2, {
@@ -19465,12 +19684,14 @@ var GitHandoffTracker = class {
         }
         reject(new Error(stderr || `git ${args2.join(" ")} failed with code ${code}`));
       });
+      child.stdin.on("error", () => {
+      });
       child.stdin.end(input);
     });
   }
 };
 function joinTempPrefix(checkpointId) {
-  return path13.join(tmpdir(), `posthog-code-handoff-${checkpointId}-`);
+  return path14.join(tmpdir(), `posthog-code-handoff-${checkpointId}-`);
 }
 async function getCurrentBranchName(git) {
   try {
@@ -19573,10 +19794,10 @@ var HandoffCheckpointTracker = class {
     }
     const gitTracker = this.createGitTracker();
     const tmpDir = await mkdtemp2(
-      join9(tmpdir2(), `posthog-code-handoff-${checkpoint.checkpointId}-`)
+      join10(tmpdir2(), `posthog-code-handoff-${checkpoint.checkpointId}-`)
     );
-    const packPath = join9(tmpDir, `${checkpoint.checkpointId}.pack`);
-    const indexPath = join9(tmpDir, `${checkpoint.checkpointId}.index`);
+    const packPath = join10(tmpDir, `${checkpoint.checkpointId}.pack`);
+    const indexPath = join10(tmpDir, `${checkpoint.checkpointId}.index`);
     try {
       const downloads = await this.downloadArtifacts([
         {
@@ -19955,9 +20176,9 @@ var PostHogAPIClient = class {
 
 // src/adapters/claude/session/jsonl-hydration.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import * as fs11 from "fs/promises";
-import * as os6 from "os";
-import * as path14 from "path";
+import * as fs12 from "fs/promises";
+import * as os7 from "os";
+import * as path15 from "path";
 var CHARS_PER_TOKEN = 4;
 var DEFAULT_MAX_TOKENS = 15e4;
 function estimateTurnTokens(turn) {
@@ -20264,9 +20485,9 @@ ${toolSummary}`);
 }
 
 // src/session-log-writer.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import fsp from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 var SessionLogWriter = class _SessionLogWriter {
   static FLUSH_DEBOUNCE_MS = 500;
   static FLUSH_MAX_INTERVAL_MS = 5e3;
@@ -20302,13 +20523,13 @@ var SessionLogWriter = class _SessionLogWriter {
     this.sessions.set(sessionId, { context, currentTurnMessages: [] });
     this.lastFlushAttemptTime.set(sessionId, Date.now());
     if (this.localCachePath) {
-      const sessionDir = path15.join(
+      const sessionDir = path16.join(
         this.localCachePath,
         "sessions",
         context.runId
       );
       try {
-        fs12.mkdirSync(sessionDir, { recursive: true });
+        fs13.mkdirSync(sessionDir, { recursive: true });
       } catch (error) {
         this.logger.warn("Failed to create local cache directory", {
           sessionDir,
@@ -20560,14 +20781,14 @@ var SessionLogWriter = class _SessionLogWriter {
     if (!this.localCachePath) return;
     const session = this.sessions.get(sessionId);
     if (!session) return;
-    const logPath = path15.join(
+    const logPath = path16.join(
       this.localCachePath,
       "sessions",
       session.context.runId,
       "logs.ndjson"
     );
     try {
-      fs12.appendFileSync(logPath, `${JSON.stringify(entry)}
+      fs13.appendFileSync(logPath, `${JSON.stringify(entry)}
 `);
     } catch (error) {
       this.logger.warn("Failed to write to local cache", {
@@ -20579,13 +20800,13 @@ var SessionLogWriter = class _SessionLogWriter {
     }
   }
   static async cleanupOldSessions(localCachePath) {
-    const sessionsDir = path15.join(localCachePath, "sessions");
+    const sessionsDir = path16.join(localCachePath, "sessions");
     let deleted = 0;
     try {
       const entries = await fsp.readdir(sessionsDir);
       const now = Date.now();
       for (const entry of entries) {
-        const entryPath = path15.join(sessionsDir, entry);
+        const entryPath = path16.join(sessionsDir, entry);
         try {
           const stats = await fsp.stat(entryPath);
           if (stats.isDirectory() && now - stats.birthtimeMs > _SessionLogWriter.SESSIONS_MAX_AGE_MS) {
@@ -20623,7 +20844,7 @@ async function getAgentshVersion() {
 }
 async function resolveAgentshRuntimeInfo({
   sessionIdPath = AGENTSH_SESSION_ID_FILE,
-  readSessionId = async (path16) => readFile5(path16, "utf8"),
+  readSessionId = async (path17) => readFile5(path17, "utf8"),
   getVersion = getAgentshVersion
 } = {}) {
   let sessionId;
@@ -21849,7 +22070,7 @@ Continue from where you left off. The user is waiting for your response.`
       throw new Error(`Failed to download artifact ${artifact.name}`);
     }
     const safeName = this.getSafeArtifactName(artifact.name);
-    const artifactDir = join11(
+    const artifactDir = join12(
       this.config.repositoryPath ?? "/tmp/workspace",
       ".posthog",
       "attachments",
@@ -21857,7 +22078,7 @@ Continue from where you left off. The user is waiting for your response.`
       artifact.id ?? safeName
     );
     await mkdir4(artifactDir, { recursive: true });
-    const artifactPath = join11(artifactDir, safeName);
+    const artifactPath = join12(artifactDir, safeName);
     await writeFile4(artifactPath, Buffer.from(data));
     return resourceLink(pathToFileURL(artifactPath).toString(), artifact.name, {
       ...artifact.content_type ? { mimeType: artifact.content_type } : {},