@posthog/agent 2.3.386 → 2.3.387

package/dist/server/agent-server.js

@@ -809,15 +809,15 @@ 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(path15, isFile2, isDirectory) {
-      log(`checking %s`, path15);
+    function check(path17, isFile2, isDirectory) {
+      log(`checking %s`, path17);
       try {
-        const stat2 = fs_1.statSync(path15);
-        if (stat2.isFile() && isFile2) {
+        const stat4 = fs_1.statSync(path17);
+        if (stat4.isFile() && isFile2) {
           log(`[OK] path represents a file`);
           return true;
         }
-        if (stat2.isDirectory() && isDirectory) {
+        if (stat4.isDirectory() && isDirectory) {
           log(`[OK] path represents a directory`);
           return true;
         }
@@ -832,8 +832,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path15, type = exports2.READABLE) {
-      return check(path15, (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(path15) {
+            function locateFile(path17) {
               if (Module["locateFile"]) {
-                return Module["locateFile"](path15, scriptDirectory);
+                return Module["locateFile"](path17, scriptDirectory);
               }
-              return scriptDirectory + path15;
+              return scriptDirectory + path17;
             }
             var readAsync, readBinary;
             if (ENVIRONMENT_IS_NODE) {
@@ -947,10 +947,10 @@ var require_tree_sitter = __commonJS({
               };
               readAsync = (filename, binary2 = true) => {
                 filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
-                return new Promise((resolve6, reject) => {
+                return new Promise((resolve7, reject) => {
                   fs.readFile(filename, binary2 ? void 0 : "utf8", (err2, data) => {
                     if (err2) reject(err2);
-                    else resolve6(binary2 ? data.buffer : data);
+                    else resolve7(binary2 ? data.buffer : data);
                   });
                 });
               };
@@ -991,13 +991,13 @@ var require_tree_sitter = __commonJS({
                 }
                 readAsync = (url) => {
                   if (isFileURI(url)) {
-                    return new Promise((reject, resolve6) => {
+                    return new Promise((reject, resolve7) => {
                       var xhr = new XMLHttpRequest();
                       xhr.open("GET", url, true);
                       xhr.responseType = "arraybuffer";
                       xhr.onload = () => {
                         if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                          resolve6(xhr.response);
+                          resolve7(xhr.response);
                         }
                         reject(xhr.status);
                       };
@@ -1957,8 +1957,8 @@ var require_tree_sitter = __commonJS({
                 }
                 var libFile = locateFile(libName2);
                 if (flags2.loadAsync) {
-                  return new Promise(function(resolve6, reject) {
-                    asyncLoad(libFile, resolve6, reject);
+                  return new Promise(function(resolve7, reject) {
+                    asyncLoad(libFile, resolve7, reject);
                   });
                 }
                 if (!readBinary) {
@@ -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) {
@@ -3784,8 +3784,8 @@ ${JSON.stringify(symbolNames, null, 2)}`);
 });
 
 // src/server/agent-server.ts
-import { mkdir as mkdir5, writeFile as writeFile5 } from "fs/promises";
-import { basename as basename2, join as join12 } from "path";
+import { mkdir as mkdir8, writeFile as writeFile6 } from "fs/promises";
+import { basename as basename2, join as join14 } 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(path15) {
-  return path15 instanceof String && cache.has(path15);
+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(path15) {
-  return (0, import_file_exists.exists)(path15, 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(path15) {
-      return /^\.(git)?$/.test(path15.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 [path15, line, preview] = input.split(NULL);
-    paths.add(path15);
-    (results[path15] = results[path15] || []).push({
+    const [path17, line, preview] = input.split(NULL);
+    paths.add(path17);
+    (results[path17] = results[path17] || []).push({
       line: asNumber(line),
-      path: path15,
+      path: path17,
       preview
     });
   });
@@ -5534,14 +5534,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path15, text2) {
+function parseInit(bare, path17, text2) {
   const response = String(text2).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path15, false, result[1]);
+    return new InitSummary(bare, path17, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path15, true, result[1]);
+    return new InitSummary(bare, path17, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -5552,7 +5552,7 @@ function parseInit(bare, path15, text2) {
       break;
     }
   }
-  return new InitSummary(bare, path15, /^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, path15, existing, gitDir) {
+      constructor(bare, path17, existing, gitDir) {
         this.bare = bare;
-        this.path = path15;
+        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, path15, 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, path15, customArgs) {
     commands,
     format: "utf-8",
     parser(text2) {
-      return parseInit(commands.includes("--bare"), path15, text2);
+      return parseInit(commands.includes("--bare"), path17, text2);
     }
   };
 }
@@ -6400,12 +6400,12 @@ var init_FileStatusSummary = __esm({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path15, index, working_dir) {
-        this.path = path15;
+      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(path15) || [null, path15, path15];
+          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, path15) {
+  function data(index, workingDir, path17) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path15);
+      handler(result, path17);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path15, index, workingDir));
+      result.files.push(new FileStatusSummary(path17, index, workingDir));
     }
   }
 }
@@ -6756,9 +6756,9 @@ var init_simple_git_api = __esm({
           next
         );
       }
-      hashObject(path15, write) {
+      hashObject(path17, write) {
         return this._runTask(
-          hashObjectTask(path15, write === true),
+          hashObjectTask(path17, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -7111,8 +7111,8 @@ var init_branch = __esm({
   }
 });
 function toPath(input) {
-  const path15 = input.trim().replace(/^["']|["']$/g, "");
-  return path15 && normalize(path15);
+  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, path15) {
-  return subModuleTask(["add", repo, path15]);
+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, path15, then) {
-      return this._runTask(addSubModuleTask2(repo, path15), 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(
@@ -8374,10 +8374,10 @@ async function getIndexLockPath(repoPath) {
 async function getLockInfo(repoPath) {
   const lockPath = await getIndexLockPath(repoPath);
   try {
-    const stat2 = await fs2.stat(lockPath);
+    const stat4 = await fs2.stat(lockPath);
     return {
       path: lockPath,
-      ageMs: Date.now() - stat2.mtimeMs
+      ageMs: Date.now() - stat4.mtimeMs
     };
   } catch {
     return null;
@@ -8412,10 +8412,10 @@ var AsyncReaderWriterLock = class {
       this.readers++;
       return;
     }
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       this.readQueue.push(() => {
         this.readers++;
-        resolve6();
+        resolve7();
       });
     });
   }
@@ -8429,11 +8429,11 @@ var AsyncReaderWriterLock = class {
       return;
     }
     this.writerWaiting = true;
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       this.writeQueue.push(() => {
         this.writerWaiting = this.writeQueue.length > 0;
         this.writer = true;
-        resolve6();
+        resolve7();
       });
     });
   }
@@ -8605,7 +8605,7 @@ import { z as z4 } from "zod";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.386",
+  version: "2.3.387",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -8665,6 +8665,10 @@ var package_default = {
       types: "./dist/resume.d.ts",
       import: "./dist/resume.js"
     },
+    "./handoff-checkpoint": {
+      types: "./dist/handoff-checkpoint.d.ts",
+      import: "./dist/handoff-checkpoint.js"
+    },
     "./tree-tracker": {
       types: "./dist/tree-tracker.d.ts",
       import: "./dist/tree-tracker.js"
@@ -8672,6 +8676,10 @@ var package_default = {
     "./server": {
       types: "./dist/server/agent-server.d.ts",
       import: "./dist/server/agent-server.js"
+    },
+    "./server/schemas": {
+      types: "./dist/server/schemas.d.ts",
+      import: "./dist/server/schemas.js"
     }
   },
   bin: {
@@ -8762,6 +8770,8 @@ var POSTHOG_NOTIFICATIONS = {
   SDK_SESSION: "_posthog/sdk_session",
   /** Tree state snapshot captured (git tree hash + file archive) */
   TREE_SNAPSHOT: "_posthog/tree_snapshot",
+  /** Git checkpoint captured for handoff */
+  GIT_CHECKPOINT: "_posthog/git_checkpoint",
   /** Agent mode changed (interactive/background) */
   MODE_CHANGE: "_posthog/mode_change",
   /** Request to resume a session from previous state */
@@ -8868,17 +8878,17 @@ var Pushable = class {
   resolvers = [];
   done = false;
   push(item) {
-    const resolve6 = this.resolvers.shift();
-    if (resolve6) {
-      resolve6({ value: item, done: false });
+    const resolve7 = this.resolvers.shift();
+    if (resolve7) {
+      resolve7({ value: item, done: false });
     } else {
       this.queue.push(item);
     }
   }
   end() {
     this.done = true;
-    for (const resolve6 of this.resolvers) {
-      resolve6({ value: void 0, done: true });
+    for (const resolve7 of this.resolvers) {
+      resolve7({ value: void 0, done: true });
     }
     this.resolvers = [];
   }
@@ -8895,8 +8905,8 @@ var Pushable = class {
             done: true
           });
         }
-        return new Promise((resolve6) => {
-          this.resolvers.push(resolve6);
+        return new Promise((resolve7) => {
+          this.resolvers.push(resolve7);
         });
       }
     };
@@ -9010,20 +9020,20 @@ function nodeReadableToWebReadable(nodeStream) {
 function nodeWritableToWebWritable(nodeStream) {
   return new WritableStream2({
     write(chunk) {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         const ok = nodeStream.write(Buffer.from(chunk), (err2) => {
           if (err2) reject(err2);
         });
         if (ok) {
-          resolve6();
+          resolve7();
         } else {
-          nodeStream.once("drain", resolve6);
+          nodeStream.once("drain", resolve7);
         }
       });
     },
     close() {
-      return new Promise((resolve6) => {
-        nodeStream.end(resolve6);
+      return new Promise((resolve7) => {
+        nodeStream.end(resolve7);
       });
     },
     abort(reason) {
@@ -12970,9 +12980,9 @@ var PostHogEnricher = class {
     }
     let mtimeMs = 0;
     try {
-      const stat2 = await fs4.stat(absPath);
-      mtimeMs = stat2.mtimeMs;
-      if (stat2.size > MAX_WRAPPER_SOURCE_BYTES) {
+      const stat22 = await fs4.stat(absPath);
+      mtimeMs = stat22.mtimeMs;
+      if (stat22.size > MAX_WRAPPER_SOURCE_BYTES) {
         return this.setWrapperCache(absPath, mtimeMs, []);
       }
     } catch {
@@ -13138,7 +13148,7 @@ async function buildWrapperContext(deps, content, langId, absPath) {
 // src/utils/common.ts
 async function withTimeout(operation, timeoutMs) {
   const timeoutPromise = new Promise(
-    (resolve6) => setTimeout(() => resolve6({ result: "timeout" }), timeoutMs)
+    (resolve7) => setTimeout(() => resolve7({ result: "timeout" }), timeoutMs)
   );
   const operationPromise = operation.then((value) => ({
     result: "success",
@@ -13436,8 +13446,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path15, oldText, newText) {
-    this.items.push({ type: "diff", path: path15, oldText, newText });
+  diff(path17, oldText, newText) {
+    this.items.push({ type: "diff", path: path17, oldText, newText });
     return this;
   }
   build() {
@@ -13624,7 +13634,7 @@ function buildToolKey(serverName, toolName) {
   return `mcp__${serverName}__${toolName}`;
 }
 function delay2(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 async function fetchMcpToolMetadata(q, logger = new Logger({ debug: false, prefix: "[McpToolMetadata]" })) {
   let retries = 0;
@@ -15945,8 +15955,8 @@ var AsyncMutex = class {
       this.locked = true;
       return;
     }
-    return new Promise((resolve6) => {
-      this.queue.push(resolve6);
+    return new Promise((resolve7) => {
+      this.queue.push(resolve7);
     });
   }
   release() {
@@ -16473,8 +16483,8 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     if (this.session.promptRunning) {
       this.session.input.push(userMessage);
       const order = this.session.nextPendingOrder++;
-      const cancelled = await new Promise((resolve6) => {
-        this.session.pendingMessages.set(promptUuid, { resolve: resolve6, order });
+      const cancelled = await new Promise((resolve7) => {
+        this.session.pendingMessages.set(promptUuid, { resolve: resolve7, order });
       });
       if (cancelled) {
         return { stopReason: "cancelled" };
@@ -17355,7 +17365,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
    */
   deferBackgroundFetches(q) {
     Promise.all([
-      new Promise((resolve6) => setTimeout(resolve6, 10)).then(
+      new Promise((resolve7) => setTimeout(resolve7, 10)).then(
         () => this.sendAvailableCommandsUpdate()
       ),
       fetchMcpToolMetadata(q, this.logger).then(() => {
@@ -18323,245 +18333,19 @@ function createCodexConnection(config) {
   };
 }
 
-// src/utils/gateway.ts
-function getGatewayBaseUrl(posthogHost) {
-  const url = new URL(posthogHost);
-  const hostname = url.hostname;
-  if (hostname === "localhost" || hostname === "127.0.0.1") {
-    return `${url.protocol}//localhost:3308`;
-  }
-  if (hostname === "host.docker.internal") {
-    return `${url.protocol}//host.docker.internal:3308`;
-  }
-  const region = hostname.match(/^(us|eu)\.posthog\.com$/)?.[1] ?? "us";
-  return `https://gateway.${region}.posthog.com`;
-}
-function getLlmGatewayUrl(posthogHost, product = "posthog_code") {
-  return `${getGatewayBaseUrl(posthogHost)}/${product}`;
-}
+// src/handoff-checkpoint.ts
+import { mkdir as mkdir4, readFile as readFile4, rm as rm4, writeFile as writeFile2 } from "fs/promises";
+import { join as join9 } from "path";
 
-// src/posthog-api.ts
-var DEFAULT_USER_AGENT = `posthog/agent.hog.dev; version: ${package_default.version}`;
-var PostHogAPIClient = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  get baseUrl() {
-    const host = this.config.apiUrl.endsWith("/") ? this.config.apiUrl.slice(0, -1) : this.config.apiUrl;
-    return host;
-  }
-  isAuthFailure(status) {
-    return status === 401 || status === 403;
-  }
-  async resolveApiKey(forceRefresh = false) {
-    if (forceRefresh && this.config.refreshApiKey) {
-      return this.config.refreshApiKey();
-    }
-    return this.config.getApiKey();
-  }
-  async buildHeaders(options, forceRefresh = false) {
-    const headers = new Headers(options.headers);
-    headers.set(
-      "Authorization",
-      `Bearer ${await this.resolveApiKey(forceRefresh)}`
-    );
-    headers.set("Content-Type", "application/json");
-    headers.set("User-Agent", this.config.userAgent ?? DEFAULT_USER_AGENT);
-    return headers;
-  }
-  async performRequest(endpoint, options, forceRefresh = false) {
-    const url = `${this.baseUrl}${endpoint}`;
-    return fetch(url, {
-      ...options,
-      headers: await this.buildHeaders(options, forceRefresh)
-    });
-  }
-  async performRequestWithRetry(endpoint, options = {}) {
-    let response = await this.performRequest(endpoint, options);
-    if (!response.ok && this.isAuthFailure(response.status)) {
-      response = await this.performRequest(endpoint, options, true);
-    }
-    return response;
-  }
-  async apiRequest(endpoint, options = {}) {
-    const response = await this.performRequestWithRetry(endpoint, options);
-    if (!response.ok) {
-      let errorMessage;
-      try {
-        const errorResponse = await response.json();
-        errorMessage = `Failed request: [${response.status}] ${JSON.stringify(errorResponse)}`;
-      } catch {
-        errorMessage = `Failed request: [${response.status}] ${response.statusText}`;
-      }
-      throw new Error(errorMessage);
-    }
-    return response.json();
-  }
-  getTeamId() {
-    return this.config.projectId;
-  }
-  async getApiKey(forceRefresh = false) {
-    return this.resolveApiKey(forceRefresh);
-  }
-  getLlmGatewayUrl() {
-    return getLlmGatewayUrl(this.baseUrl);
-  }
-  async getTask(taskId) {
-    const teamId = this.getTeamId();
-    return this.apiRequest(`/api/projects/${teamId}/tasks/${taskId}/`);
-  }
-  async getTaskRun(taskId, runId) {
-    const teamId = this.getTeamId();
-    return this.apiRequest(
-      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`
-    );
-  }
-  async updateTaskRun(taskId, runId, payload) {
-    const teamId = this.getTeamId();
-    return this.apiRequest(
-      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`,
-      {
-        method: "PATCH",
-        body: JSON.stringify(payload)
-      }
-    );
-  }
-  async setTaskRunOutput(taskId, runId, output) {
-    return this.apiRequest(
-      `/api/projects/${this.getTeamId()}/tasks/${taskId}/runs/${runId}/set_output/`,
-      {
-        method: "PATCH",
-        body: JSON.stringify(output)
-      }
-    );
-  }
-  async appendTaskRunLog(taskId, runId, entries) {
-    const teamId = this.getTeamId();
-    return this.apiRequest(
-      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/append_log/`,
-      {
-        method: "POST",
-        body: JSON.stringify({ entries })
-      }
-    );
-  }
-  async relayMessage(taskId, runId, text2) {
-    const teamId = this.getTeamId();
-    await this.apiRequest(
-      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/relay_message/`,
-      {
-        method: "POST",
-        body: JSON.stringify({ text: text2 })
-      }
-    );
-  }
-  async uploadTaskArtifacts(taskId, runId, artifacts) {
-    if (!artifacts.length) {
-      return [];
-    }
-    const teamId = this.getTeamId();
-    const response = await this.apiRequest(
-      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/artifacts/`,
-      {
-        method: "POST",
-        body: JSON.stringify({ artifacts })
-      }
-    );
-    return response.artifacts ?? [];
-  }
-  /**
-   * Download artifact content by storage path
-   * Streams the file through the PostHog backend so the sandbox does not need
-   * direct access to object storage.
-   */
-  async downloadArtifact(taskId, runId, storagePath) {
-    const teamId = this.getTeamId();
-    try {
-      const response = await this.performRequestWithRetry(
-        `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/artifacts/download/`,
-        {
-          method: "POST",
-          body: JSON.stringify({ storage_path: storagePath })
-        }
-      );
-      if (!response.ok) {
-        throw new Error(`Failed to download artifact: ${response.status}`);
-      }
-      return response.arrayBuffer();
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Fetch logs for a task run via the logs API endpoint
-   * @param taskRun - The task run to fetch logs for
-   * @returns Array of stored entries, or empty array if no logs available
-   */
-  async fetchTaskRunLogs(taskRun) {
-    const teamId = this.getTeamId();
-    const endpoint = `/api/projects/${teamId}/tasks/${taskRun.task}/runs/${taskRun.id}/logs`;
-    try {
-      const response = await this.performRequestWithRetry(endpoint);
-      if (!response.ok) {
-        if (response.status === 404) {
-          return [];
-        }
-        throw new Error(
-          `Failed to fetch logs: ${response.status} ${response.statusText}`
-        );
-      }
-      const content = await response.text();
-      if (!content.trim()) {
-        return [];
-      }
-      return content.trim().split("\n").map((line) => JSON.parse(line));
-    } catch (error) {
-      throw new Error(
-        `Failed to fetch task run logs: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-};
+// ../git/dist/handoff.js
+import { spawn as spawn4 } from "child_process";
+import { copyFile, mkdir as mkdir3, readFile as readFile3, rm as rm3, stat as stat3 } from "fs/promises";
+import path13 from "path";
 
-// src/adapters/claude/session/jsonl-hydration.ts
+// ../git/dist/sagas/checkpoint.js
 import { randomUUID as randomUUID2 } from "crypto";
 import * as fs10 from "fs/promises";
-import * as os6 from "os";
 import * as path12 from "path";
-var CHARS_PER_TOKEN = 4;
-var DEFAULT_MAX_TOKENS = 15e4;
-function estimateTurnTokens(turn) {
-  let chars = 0;
-  for (const block of turn.content) {
-    if ("text" in block && typeof block.text === "string") {
-      chars += block.text.length;
-    }
-  }
-  if (turn.toolCalls) {
-    for (const tc of turn.toolCalls) {
-      chars += JSON.stringify(tc.input ?? "").length;
-      if (tc.result !== void 0) {
-        chars += typeof tc.result === "string" ? tc.result.length : JSON.stringify(tc.result).length;
-      }
-    }
-  }
-  return Math.ceil(chars / CHARS_PER_TOKEN);
-}
-function selectRecentTurns(turns, maxTokens = DEFAULT_MAX_TOKENS) {
-  let budget = maxTokens;
-  let startIndex = turns.length;
-  for (let i2 = turns.length - 1; i2 >= 0; i2--) {
-    const cost = estimateTurnTokens(turns[i2]);
-    if (cost > budget) break;
-    budget -= cost;
-    startIndex = i2;
-  }
-  while (startIndex < turns.length && turns[startIndex].role !== "user") {
-    startIndex++;
-  }
-  return turns.slice(startIndex);
-}
 
 // ../shared/dist/index.js
 var CLOUD_PROMPT_PREFIX = "__twig_cloud_prompt_v1__:";
@@ -18705,16 +18489,6 @@ var Saga = class {
   }
 };
 
-// src/sagas/apply-snapshot-saga.ts
-import { mkdir as mkdir4, rm as rm3, writeFile as writeFile4 } from "fs/promises";
-import { join as join10 } from "path";
-
-// ../git/dist/sagas/tree.js
-import { existsSync as existsSync5 } from "fs";
-import * as fs11 from "fs/promises";
-import * as path13 from "path";
-import * as tar from "tar";
-
 // ../git/dist/git-saga.js
 var GitSaga = class extends Saga {
   _git = null;
@@ -18733,20 +18507,1082 @@ var GitSaga = class extends Saga {
   }
 };
 
-// ../git/dist/sagas/tree.js
-var CaptureTreeSaga = class extends GitSaga {
-  sagaName = "CaptureTreeSaga";
-  tempIndexPath = null;
+// ../git/dist/sagas/checkpoint.js
+var CHECKPOINT_REF_PREFIX = "refs/posthog-code-checkpoint/";
+var CHECKPOINT_VERSION = "v1";
+var UNMERGED_INDEX_ERROR = "Cannot capture checkpoint with unresolved merge conflicts in the index";
+var GIT_BUSY_ERROR = "Cannot capture checkpoint while git operation is in progress";
+var CHECKPOINT_AUTHOR = {
+  name: "PostHog Code",
+  email: "posthog-code@local"
+};
+var CaptureCheckpointSaga = class extends GitSaga {
+  sagaName = "CaptureCheckpointSaga";
   async executeGitOperations(input) {
-    const { baseDir, lastTreeHash, archivePath, signal } = input;
-    const tmpDir = path13.join(baseDir, ".git", "posthog-code-tmp");
-    await this.step({
-      name: "create_tmp_dir",
-      execute: () => fs11.mkdir(tmpDir, { recursive: true }),
+    const { baseDir } = input;
+    const headInfo = await this.readOnlyStep("get_head_info", () => getHeadInfo(this.git));
+    const busyState = await this.readOnlyStep("check_git_busy", () => getGitBusyState(this.git));
+    if (busyState.busy) {
+      throw new Error(`${GIT_BUSY_ERROR}: ${busyState.operation}`);
+    }
+    const hasUnmerged = await this.readOnlyStep("check_unmerged_index", () => hasUnmergedEntries(this.git));
+    if (hasUnmerged) {
+      throw new Error(UNMERGED_INDEX_ERROR);
+    }
+    const indexTree = await this.readOnlyStep("write_index_tree", () => this.git.raw(["write-tree"]));
+    const worktreeTree = await this.readOnlyStep("write_worktree_tree", () => createWorktreeTree(this.git, baseDir, headInfo.head));
+    const metaTree = await this.readOnlyStep("write_meta_tree", () => createMetaTree(this.git, baseDir, indexTree.trim(), worktreeTree.trim()));
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const message = formatCheckpointMessage({
+      head: headInfo.head,
+      branch: headInfo.branch,
+      indexTree: indexTree.trim(),
+      worktreeTree: worktreeTree.trim(),
+      timestamp
+    });
+    const commitHash = await this.step({
+      name: "create_checkpoint_commit",
+      execute: async () => {
+        const commitGit = this.git.env({
+          ...process.env,
+          GIT_AUTHOR_NAME: CHECKPOINT_AUTHOR.name,
+          GIT_AUTHOR_EMAIL: CHECKPOINT_AUTHOR.email,
+          GIT_COMMITTER_NAME: CHECKPOINT_AUTHOR.name,
+          GIT_COMMITTER_EMAIL: CHECKPOINT_AUTHOR.email
+        });
+        const rawCommit = await commitGit.raw([
+          "commit-tree",
+          metaTree.trim(),
+          ...headInfo.head ? ["-p", headInfo.head] : [],
+          "-m",
+          message
+        ]);
+        return rawCommit.trim();
+      },
       rollback: async () => {
       }
     });
-    this.tempIndexPath = path13.join(tmpDir, `index-${Date.now()}`);
+    const checkpointId = input.checkpointId ?? randomUUID2();
+    const refName = `${CHECKPOINT_REF_PREFIX}${checkpointId}`;
+    const existingRef = await this.readOnlyStep("check_existing_ref", async () => {
+      try {
+        await this.git.revparse(["--verify", refName]);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (existingRef) {
+      throw new Error(`Checkpoint ref already exists: ${refName}`);
+    }
+    await this.step({
+      name: "update_checkpoint_ref",
+      execute: () => this.git.raw(["update-ref", refName, commitHash]),
+      rollback: async () => {
+        await this.git.raw(["update-ref", "-d", refName]).catch(() => {
+        });
+      }
+    });
+    return {
+      checkpointId,
+      commit: commitHash,
+      head: headInfo.head,
+      branch: headInfo.branch,
+      indexTree: indexTree.trim(),
+      worktreeTree: worktreeTree.trim(),
+      timestamp
+    };
+  }
+};
+async function getHeadInfo(git) {
+  let head = null;
+  let branch = null;
+  try {
+    head = (await git.revparse(["HEAD"]))?.trim() || null;
+  } catch {
+    head = null;
+  }
+  try {
+    const rawBranch = await git.raw(["symbolic-ref", "--short", "HEAD"]);
+    branch = rawBranch.trim() || null;
+  } catch {
+    branch = null;
+  }
+  return { head, branch };
+}
+async function hasUnmergedEntries(git) {
+  const output = await git.raw(["ls-files", "--unmerged"]);
+  return output.trim().length > 0;
+}
+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);
+  };
+  const pathExists = async (gitPath) => {
+    const resolved = await resolveGitPath(gitPath);
+    try {
+      await fs10.access(resolved);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const dirExists = async (gitPath) => {
+    const resolved = await resolveGitPath(gitPath);
+    try {
+      const stat4 = await fs10.stat(resolved);
+      return stat4.isDirectory();
+    } catch {
+      return false;
+    }
+  };
+  if (await dirExists("rebase-merge") || await dirExists("rebase-apply")) {
+    return { busy: true, operation: "rebase" };
+  }
+  if (await pathExists("MERGE_HEAD")) {
+    return { busy: true, operation: "merge" };
+  }
+  if (await pathExists("CHERRY_PICK_HEAD")) {
+    return { busy: true, operation: "cherry-pick" };
+  }
+  if (await pathExists("REVERT_HEAD")) {
+    return { busy: true, operation: "revert" };
+  }
+  return { busy: false };
+}
+async function createWorktreeTree(git, baseDir, head) {
+  const { tempGit, tempIndexPath } = await createTempIndexGit(git, baseDir, "checkpoint-worktree");
+  try {
+    if (head) {
+      await tempGit.raw(["read-tree", head]);
+    } else {
+      await tempGit.raw(["read-tree", "--empty"]);
+    }
+    await tempGit.raw(["add", "-A", "--", "."]);
+    const treeHash = await tempGit.raw(["write-tree"]);
+    return treeHash.trim();
+  } finally {
+    await fs10.rm(tempIndexPath, { force: true }).catch(() => {
+    });
+  }
+}
+async function createMetaTree(git, baseDir, indexTree, worktreeTree) {
+  const { tempGit, tempIndexPath } = await createTempIndexGit(git, baseDir, "checkpoint-meta");
+  try {
+    await tempGit.raw(["read-tree", "--empty"]);
+    await tempGit.raw([
+      "update-index",
+      "--add",
+      "--cacheinfo",
+      "040000",
+      indexTree,
+      "index"
+    ]);
+    await tempGit.raw([
+      "update-index",
+      "--add",
+      "--cacheinfo",
+      "040000",
+      worktreeTree,
+      "worktree"
+    ]);
+    const metaTree = await tempGit.raw(["write-tree"]);
+    return metaTree.trim();
+  } finally {
+    await fs10.rm(tempIndexPath, { force: true }).catch(() => {
+    });
+  }
+}
+function formatCheckpointMessage(meta) {
+  return [
+    `POSTHOG-CODE-CHECKPOINT ${CHECKPOINT_VERSION}`,
+    `head=${meta.head ?? "null"}`,
+    `branch=${meta.branch ?? "null"}`,
+    `index=${meta.indexTree}`,
+    `worktree=${meta.worktreeTree}`,
+    `timestamp=${meta.timestamp}`
+  ].join("\n");
+}
+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);
+}
+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 tempGit = createGitClient(baseDir).env({
+    ...process.env,
+    GIT_INDEX_FILE: tempIndexPath
+  });
+  return { tempGit, tempIndexPath };
+}
+async function refExists(git, refName) {
+  try {
+    await git.revparse(["--verify", refName]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function deleteCheckpoint(git, checkpointId) {
+  const refName = `${CHECKPOINT_REF_PREFIX}${checkpointId}`;
+  const exists2 = await refExists(git, refName);
+  if (!exists2) {
+    throw new Error(`Checkpoint not found: ${checkpointId}`);
+  }
+  await git.raw(["update-ref", "-d", refName]);
+}
+
+// ../git/dist/handoff.js
+var HANDOFF_HEAD_REF_PREFIX = "refs/posthog-code-handoff/head/";
+var CHECKPOINT_REF_PREFIX2 = "refs/posthog-code-checkpoint/";
+var GitHandoffTracker = class {
+  repositoryPath;
+  logger;
+  constructor(config) {
+    this.repositoryPath = config.repositoryPath;
+    this.logger = config.logger;
+  }
+  async captureForHandoff(localGitState) {
+    const captureSaga = new CaptureCheckpointSaga(this.logger);
+    const result = await captureSaga.run({ baseDir: this.repositoryPath });
+    if (!result.success) {
+      throw new Error(`Failed to capture checkpoint at step '${result.failedStep}': ${result.error}`);
+    }
+    const checkpoint = result.data;
+    const git = createGitClient(this.repositoryPath);
+    const tempDir = await this.getTempDir(git);
+    const checkpointRef = `${CHECKPOINT_REF_PREFIX2}${checkpoint.checkpointId}`;
+    const shouldIncludeHead = !!checkpoint.head && checkpoint.head !== localGitState?.head;
+    const headRef = shouldIncludeHead ? `${HANDOFF_HEAD_REF_PREFIX}${checkpoint.checkpointId}` : void 0;
+    const packPrefix = path13.join(tempDir, checkpoint.checkpointId);
+    try {
+      const [headPack, indexFile, tracking] = await Promise.all([
+        shouldIncludeHead && checkpoint.head ? this.captureHeadPack(packPrefix, checkpoint.head) : Promise.resolve(void 0),
+        this.copyIndexFile(git, checkpoint.checkpointId),
+        getTrackingMetadata(git, checkpoint.branch)
+      ]);
+      return {
+        checkpoint: {
+          checkpointId: checkpoint.checkpointId,
+          commit: checkpoint.commit,
+          checkpointRef,
+          headRef,
+          head: checkpoint.head,
+          branch: checkpoint.branch,
+          indexTree: checkpoint.indexTree,
+          worktreeTree: checkpoint.worktreeTree,
+          timestamp: checkpoint.timestamp,
+          upstreamRemote: tracking.upstreamRemote,
+          upstreamMergeRef: tracking.upstreamMergeRef,
+          remoteUrl: tracking.remoteUrl
+        },
+        headPack,
+        indexFile,
+        totalBytes: (headPack?.rawBytes ?? 0) + indexFile.rawBytes
+      };
+    } finally {
+      await deleteCheckpoint(git, checkpoint.checkpointId).catch(() => {
+      });
+    }
+  }
+  async applyFromHandoff(input) {
+    const { checkpoint, headPackPath, indexPath, localGitState, onDivergedBranch } = input;
+    const git = createGitClient(this.repositoryPath);
+    if (headPackPath) {
+      await this.unpackPackFile(headPackPath);
+    }
+    if (checkpoint.branch && checkpoint.head) {
+      const branchStatus2 = await this.resolveBranchRestoreStatus(git, checkpoint.branch, checkpoint.head, localGitState);
+      const tracking = this.getPreferredTracking(localGitState, checkpoint);
+      if (branchStatus2.kind === "diverged" && !await onDivergedBranch?.(branchStatus2.divergence)) {
+        throw new Error(`Handoff aborted: local branch '${checkpoint.branch}' has diverged`);
+      }
+      await this.checkoutBranchAtHead(git, checkpoint.branch, checkpoint.head);
+      if (this.shouldRestoreTracking(branchStatus2, localGitState, tracking)) {
+        await this.ensureRemoteForTracking(git, tracking);
+        await this.configureUpstream(git, checkpoint.branch, tracking);
+      }
+    } else if (checkpoint.head) {
+      await git.checkout(checkpoint.head);
+    }
+    if (indexPath) {
+      await this.restoreIndexFile(git, indexPath);
+    }
+    const packBytes = headPackPath ? await this.getFileSize(headPackPath) : 0;
+    const indexBytes = indexPath ? await this.getFileSize(indexPath) : 0;
+    return {
+      packBytes,
+      indexBytes,
+      totalBytes: packBytes + indexBytes
+    };
+  }
+  async captureHeadPack(packPrefix, headCommit) {
+    const hash = await this.runGitWithInput(["pack-objects", packPrefix, "--revs"], `${headCommit}
+`);
+    const packPath = `${packPrefix}-${hash.trim()}.pack`;
+    const rawBytes = await this.getFileSize(packPath);
+    await rm3(`${packPath}.idx`, { force: true }).catch(() => {
+    });
+    return { path: packPath, rawBytes };
+  }
+  async copyIndexFile(git, checkpointId) {
+    const indexPath = await this.getGitPath(git, "index");
+    const tempDir = await this.getTempDir(git);
+    const copiedIndexPath = path13.join(tempDir, `${checkpointId}.index`);
+    await copyFile(indexPath, copiedIndexPath);
+    return {
+      path: copiedIndexPath,
+      rawBytes: await this.getFileSize(copiedIndexPath)
+    };
+  }
+  async restoreIndexFile(git, indexPath) {
+    const gitIndexPath = await this.getGitPath(git, "index");
+    await copyFile(indexPath, gitIndexPath);
+  }
+  async unpackPackFile(packPath) {
+    const content = await readFile3(packPath);
+    await this.runGitWithBuffer(["unpack-objects", "-r"], content);
+  }
+  getPreferredTracking(localGitState, checkpoint) {
+    const state = localGitState;
+    if (state && hasTrackingConfig(state)) {
+      return {
+        upstreamRemote: state.upstreamRemote ?? null,
+        upstreamMergeRef: state.upstreamMergeRef ?? null,
+        remoteUrl: state.upstreamRemote && state.upstreamRemote === checkpoint.upstreamRemote ? checkpoint.remoteUrl : null
+      };
+    }
+    return {
+      upstreamRemote: checkpoint.upstreamRemote,
+      upstreamMergeRef: checkpoint.upstreamMergeRef,
+      remoteUrl: checkpoint.remoteUrl
+    };
+  }
+  shouldRestoreTracking(branchStatus2, localGitState, tracking) {
+    return branchStatus2.kind === "missing" || !hasTrackingConfig(localGitState) && (tracking.upstreamRemote !== null || tracking.upstreamMergeRef !== null);
+  }
+  async ensureRemoteForTracking(git, tracking) {
+    if (!tracking.upstreamRemote || !tracking.remoteUrl)
+      return;
+    const remotes = await git.getRemotes(true);
+    const existing = remotes.find((remote) => remote.name === tracking.upstreamRemote);
+    if (!existing) {
+      await git.addRemote(tracking.upstreamRemote, tracking.remoteUrl);
+    }
+  }
+  async configureUpstream(git, branch, tracking) {
+    if (tracking.upstreamRemote) {
+      await git.raw([
+        "config",
+        `branch.${branch}.remote`,
+        tracking.upstreamRemote
+      ]);
+    }
+    if (tracking.upstreamMergeRef) {
+      await git.raw([
+        "config",
+        `branch.${branch}.merge`,
+        tracking.upstreamMergeRef
+      ]);
+    }
+  }
+  async resolveBranchRestoreStatus(git, branch, cloudHead, localGitState) {
+    const branchRef = `refs/heads/${branch}`;
+    const branchExists = await this.refExists(git, branchRef);
+    if (!branchExists) {
+      return { kind: "missing" };
+    }
+    const currentBranchHead = (await git.revparse([branchRef])).trim();
+    const candidateHeads = [
+      currentBranchHead,
+      ...localGitState?.branch === branch && localGitState.head ? [localGitState.head] : []
+    ].filter((value, index, array) => array.indexOf(value) === index);
+    if (candidateHeads.every((head) => head === cloudHead)) {
+      return { kind: "match" };
+    }
+    const nonAncestorHead = await this.findNonAncestorHead(git, candidateHeads, cloudHead);
+    if (!nonAncestorHead) {
+      return { kind: "fast_forward" };
+    }
+    return {
+      kind: "diverged",
+      divergence: {
+        branch,
+        localHead: nonAncestorHead,
+        cloudHead
+      }
+    };
+  }
+  async findNonAncestorHead(_git, heads, cloudHead) {
+    for (const head of heads) {
+      if (head === cloudHead) {
+        continue;
+      }
+      if (!await this.isAncestor(head, cloudHead)) {
+        return head;
+      }
+    }
+    return null;
+  }
+  async checkoutBranchAtHead(git, branch, head) {
+    const currentBranch = await getCurrentBranchName(git);
+    if (currentBranch === branch) {
+      await git.reset(["--hard", head]);
+      return;
+    }
+    const branchRef = `refs/heads/${branch}`;
+    if (await this.refExists(git, branchRef)) {
+      await git.branch(["-f", branch, head]);
+      await git.checkout(branch);
+      return;
+    }
+    await git.checkout(["-b", branch, head]);
+  }
+  async refExists(git, ref) {
+    try {
+      await git.revparse(["--verify", ref]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async isAncestor(ancestor, descendant) {
+    const exitCode = await this.runGitProcessAllowingFailure([
+      "merge-base",
+      "--is-ancestor",
+      ancestor,
+      descendant
+    ]);
+    return exitCode === 0;
+  }
+  async getTempDir(git) {
+    const raw = await git.raw(["rev-parse", "--git-common-dir"]);
+    const commonDir = raw.trim() || ".git";
+    const resolved = path13.isAbsolute(commonDir) ? commonDir : path13.resolve(this.repositoryPath, commonDir);
+    const tempDir = path13.join(resolved, "posthog-code-tmp");
+    await mkdir3(tempDir, { recursive: true });
+    return tempDir;
+  }
+  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);
+  }
+  async getFileSize(filePath) {
+    return (await stat3(filePath)).size;
+  }
+  async runGitWithInput(args2, input) {
+    const { stdout } = await this.runGitProcess(args2, input);
+    return stdout;
+  }
+  async runGitWithBuffer(args2, input) {
+    await this.runGitProcess(args2, input);
+  }
+  async runGitProcessAllowingFailure(args2) {
+    return new Promise((resolve7, reject) => {
+      const child = spawn4("git", args2, {
+        cwd: this.repositoryPath,
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+      let stderr = "";
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("error", reject);
+      child.on("close", (code) => {
+        if (code === null) {
+          reject(new Error(`git ${args2.join(" ")} exited unexpectedly`));
+          return;
+        }
+        if (code > 1) {
+          reject(new Error(stderr || `git ${args2.join(" ")} failed with code ${code}`));
+          return;
+        }
+        resolve7(code);
+      });
+    });
+  }
+  runGitProcess(args2, input) {
+    return new Promise((resolve7, reject) => {
+      const child = spawn4("git", args2, {
+        cwd: this.repositoryPath,
+        stdio: "pipe"
+      });
+      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, stderr });
+          return;
+        }
+        reject(new Error(stderr || `git ${args2.join(" ")} failed with code ${code}`));
+      });
+      child.stdin.end(input);
+    });
+  }
+};
+async function getCurrentBranchName(git) {
+  try {
+    const raw = await git.revparse(["--abbrev-ref", "HEAD"]);
+    const branch = raw.trim();
+    return branch === "HEAD" ? null : branch;
+  } catch {
+    return null;
+  }
+}
+async function getTrackingMetadata(git, branch) {
+  if (!branch) {
+    return {
+      upstreamRemote: null,
+      upstreamMergeRef: null,
+      remoteUrl: null
+    };
+  }
+  const upstreamRemote = await getGitConfigValue(git, `branch.${branch}.remote`);
+  const upstreamMergeRef = await getGitConfigValue(git, `branch.${branch}.merge`);
+  const remoteUrl = upstreamRemote ? await getRemoteUrl(git, upstreamRemote) : null;
+  return { upstreamRemote, upstreamMergeRef, remoteUrl };
+}
+async function getGitConfigValue(git, key) {
+  try {
+    const value = await git.raw(["config", "--get", key]);
+    return value.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function getRemoteUrl(git, remote) {
+  try {
+    const value = await git.remote(["get-url", remote]);
+    return typeof value === "string" ? value.trim() || null : null;
+  } catch {
+    return null;
+  }
+}
+function hasTrackingConfig(localGitState) {
+  return !!(localGitState?.upstreamRemote || localGitState?.upstreamMergeRef);
+}
+
+// src/handoff-checkpoint.ts
+var HandoffCheckpointTracker = class {
+  repositoryPath;
+  taskId;
+  runId;
+  apiClient;
+  logger;
+  constructor(config) {
+    this.repositoryPath = config.repositoryPath;
+    this.taskId = config.taskId;
+    this.runId = config.runId;
+    this.apiClient = config.apiClient;
+    this.logger = config.logger || new Logger({ debug: false, prefix: "[HandoffCheckpointTracker]" });
+  }
+  async captureForHandoff(localGitState) {
+    if (!this.apiClient) {
+      throw new Error(
+        "Cannot capture handoff checkpoint: API client not configured"
+      );
+    }
+    const gitTracker = this.createGitTracker();
+    const capture = await gitTracker.captureForHandoff(localGitState);
+    try {
+      const uploads = await this.uploadArtifacts([
+        {
+          key: "pack",
+          filePath: capture.headPack?.path,
+          name: `handoff/${capture.checkpoint.checkpointId}.pack`,
+          contentType: "application/x-git-packed-objects"
+        },
+        {
+          key: "index",
+          filePath: capture.indexFile.path,
+          name: `handoff/${capture.checkpoint.checkpointId}.index`,
+          contentType: "application/octet-stream"
+        }
+      ]);
+      this.logCaptureMetrics(capture.checkpoint, uploads);
+      return {
+        ...capture.checkpoint,
+        artifactPath: uploads.pack?.storagePath,
+        indexArtifactPath: uploads.index?.storagePath
+      };
+    } finally {
+      await this.removeIfPresent(capture.headPack?.path);
+      await this.removeIfPresent(capture.indexFile.path);
+    }
+  }
+  async applyFromHandoff(checkpoint, options) {
+    if (!this.apiClient) {
+      throw new Error(
+        "Cannot apply handoff checkpoint: API client not configured"
+      );
+    }
+    const gitTracker = this.createGitTracker();
+    const tmpDir = join9(this.repositoryPath, ".posthog", "tmp");
+    await mkdir4(tmpDir, { recursive: true });
+    const packPath = join9(tmpDir, `${checkpoint.checkpointId}.pack`);
+    const indexPath = join9(tmpDir, `${checkpoint.checkpointId}.index`);
+    try {
+      const downloads = await this.downloadArtifacts([
+        {
+          key: "pack",
+          storagePath: checkpoint.artifactPath,
+          filePath: packPath,
+          label: "handoff pack"
+        },
+        {
+          key: "index",
+          storagePath: checkpoint.indexArtifactPath,
+          filePath: indexPath,
+          label: "handoff index"
+        }
+      ]);
+      const applyResult = await gitTracker.applyFromHandoff({
+        checkpoint: this.toGitCheckpoint(checkpoint),
+        headPackPath: downloads.pack?.filePath,
+        indexPath: downloads.index?.filePath,
+        localGitState: options?.localGitState,
+        onDivergedBranch: options?.onDivergedBranch
+      });
+      this.logApplyMetrics(checkpoint, downloads, applyResult.totalBytes);
+    } finally {
+      await this.removeIfPresent(packPath);
+      await this.removeIfPresent(indexPath);
+    }
+  }
+  toGitCheckpoint(checkpoint) {
+    return {
+      checkpointId: checkpoint.checkpointId,
+      commit: checkpoint.commit,
+      checkpointRef: checkpoint.checkpointRef,
+      headRef: checkpoint.headRef,
+      head: checkpoint.head,
+      branch: checkpoint.branch,
+      indexTree: checkpoint.indexTree,
+      worktreeTree: checkpoint.worktreeTree,
+      timestamp: checkpoint.timestamp,
+      upstreamRemote: checkpoint.upstreamRemote ?? null,
+      upstreamMergeRef: checkpoint.upstreamMergeRef ?? null,
+      remoteUrl: checkpoint.remoteUrl ?? null
+    };
+  }
+  async uploadArtifactFile(filePath, name2, contentType) {
+    if (!this.apiClient) {
+      return { rawBytes: 0, wireBytes: 0 };
+    }
+    const content = await readFile4(filePath);
+    const base64Content = content.toString("base64");
+    const artifacts = await this.apiClient.uploadTaskArtifacts(
+      this.taskId,
+      this.runId,
+      [
+        {
+          name: name2,
+          type: "artifact",
+          content: base64Content,
+          content_type: contentType
+        }
+      ]
+    );
+    return {
+      storagePath: artifacts.at(-1)?.storage_path,
+      rawBytes: content.byteLength,
+      wireBytes: Buffer.byteLength(base64Content, "utf-8")
+    };
+  }
+  async uploadArtifacts(specs) {
+    const uploads = await Promise.all(
+      specs.map(async (spec) => {
+        if (!spec.filePath) {
+          return [spec.key, void 0];
+        }
+        return [
+          spec.key,
+          await this.uploadArtifactFile(
+            spec.filePath,
+            spec.name,
+            spec.contentType
+          )
+        ];
+      })
+    );
+    return Object.fromEntries(uploads);
+  }
+  async downloadArtifactToFile(artifactPath, filePath, label) {
+    if (!this.apiClient) {
+      throw new Error(`Cannot download ${label}: API client not configured`);
+    }
+    const arrayBuffer = await this.apiClient.downloadArtifact(
+      this.taskId,
+      this.runId,
+      artifactPath
+    );
+    if (!arrayBuffer) {
+      throw new Error(`Failed to download ${label}`);
+    }
+    const base64Content = Buffer.from(arrayBuffer).toString("utf-8");
+    const binaryContent = Buffer.from(base64Content, "base64");
+    await writeFile2(filePath, binaryContent);
+    return {
+      filePath,
+      rawBytes: binaryContent.byteLength,
+      wireBytes: arrayBuffer.byteLength
+    };
+  }
+  async downloadArtifacts(specs) {
+    const downloads = await Promise.all(
+      specs.map(async (spec) => {
+        if (!spec.storagePath) {
+          return [spec.key, void 0];
+        }
+        return [
+          spec.key,
+          await this.downloadArtifactToFile(
+            spec.storagePath,
+            spec.filePath,
+            spec.label
+          )
+        ];
+      })
+    );
+    return Object.fromEntries(downloads);
+  }
+  createGitTracker() {
+    return new GitHandoffTracker({
+      repositoryPath: this.repositoryPath,
+      logger: this.logger
+    });
+  }
+  logCaptureMetrics(checkpoint, uploads) {
+    this.logger.info("Captured handoff checkpoint", {
+      checkpointId: checkpoint.checkpointId,
+      branch: checkpoint.branch,
+      head: checkpoint.head,
+      artifactPath: uploads.pack?.storagePath,
+      indexArtifactPath: uploads.index?.storagePath,
+      ...this.buildMetricPayload(uploads)
+    });
+  }
+  logApplyMetrics(checkpoint, downloads, totalBytes) {
+    this.logger.info("Applied handoff checkpoint", {
+      checkpointId: checkpoint.checkpointId,
+      commit: checkpoint.commit,
+      branch: checkpoint.branch,
+      head: checkpoint.head,
+      packBytes: downloads.pack?.rawBytes ?? 0,
+      packWireBytes: downloads.pack?.wireBytes ?? 0,
+      indexBytes: downloads.index?.rawBytes ?? 0,
+      indexWireBytes: downloads.index?.wireBytes ?? 0,
+      totalBytes,
+      totalWireBytes: this.sumWireBytes(downloads.pack, downloads.index)
+    });
+  }
+  buildMetricPayload(metrics) {
+    return {
+      packBytes: metrics.pack?.rawBytes ?? 0,
+      packWireBytes: metrics.pack?.wireBytes ?? 0,
+      indexBytes: metrics.index?.rawBytes ?? 0,
+      indexWireBytes: metrics.index?.wireBytes ?? 0,
+      totalBytes: this.sumRawBytes(metrics.pack, metrics.index),
+      totalWireBytes: this.sumWireBytes(metrics.pack, metrics.index)
+    };
+  }
+  sumRawBytes(...artifacts) {
+    return artifacts.reduce(
+      (total, artifact) => total + (artifact?.rawBytes ?? 0),
+      0
+    );
+  }
+  sumWireBytes(...artifacts) {
+    return artifacts.reduce(
+      (total, artifact) => total + (artifact?.wireBytes ?? 0),
+      0
+    );
+  }
+  async removeIfPresent(filePath) {
+    if (!filePath) {
+      return;
+    }
+    await rm4(filePath, { force: true }).catch(() => {
+    });
+  }
+};
+
+// src/utils/gateway.ts
+function getGatewayBaseUrl(posthogHost) {
+  const url = new URL(posthogHost);
+  const hostname = url.hostname;
+  if (hostname === "localhost" || hostname === "127.0.0.1") {
+    return `${url.protocol}//localhost:3308`;
+  }
+  if (hostname === "host.docker.internal") {
+    return `${url.protocol}//host.docker.internal:3308`;
+  }
+  const region = hostname.match(/^(us|eu)\.posthog\.com$/)?.[1] ?? "us";
+  return `https://gateway.${region}.posthog.com`;
+}
+function getLlmGatewayUrl(posthogHost, product = "posthog_code") {
+  return `${getGatewayBaseUrl(posthogHost)}/${product}`;
+}
+
+// src/posthog-api.ts
+var DEFAULT_USER_AGENT = `posthog/agent.hog.dev; version: ${package_default.version}`;
+var PostHogAPIClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  get baseUrl() {
+    const host = this.config.apiUrl.endsWith("/") ? this.config.apiUrl.slice(0, -1) : this.config.apiUrl;
+    return host;
+  }
+  isAuthFailure(status) {
+    return status === 401 || status === 403;
+  }
+  async resolveApiKey(forceRefresh = false) {
+    if (forceRefresh && this.config.refreshApiKey) {
+      return this.config.refreshApiKey();
+    }
+    return this.config.getApiKey();
+  }
+  async buildHeaders(options, forceRefresh = false) {
+    const headers = new Headers(options.headers);
+    headers.set(
+      "Authorization",
+      `Bearer ${await this.resolveApiKey(forceRefresh)}`
+    );
+    headers.set("Content-Type", "application/json");
+    headers.set("User-Agent", this.config.userAgent ?? DEFAULT_USER_AGENT);
+    return headers;
+  }
+  async performRequest(endpoint, options, forceRefresh = false) {
+    const url = `${this.baseUrl}${endpoint}`;
+    return fetch(url, {
+      ...options,
+      headers: await this.buildHeaders(options, forceRefresh)
+    });
+  }
+  async performRequestWithRetry(endpoint, options = {}) {
+    let response = await this.performRequest(endpoint, options);
+    if (!response.ok && this.isAuthFailure(response.status)) {
+      response = await this.performRequest(endpoint, options, true);
+    }
+    return response;
+  }
+  async apiRequest(endpoint, options = {}) {
+    const response = await this.performRequestWithRetry(endpoint, options);
+    if (!response.ok) {
+      let errorMessage;
+      try {
+        const errorResponse = await response.json();
+        errorMessage = `Failed request: [${response.status}] ${JSON.stringify(errorResponse)}`;
+      } catch {
+        errorMessage = `Failed request: [${response.status}] ${response.statusText}`;
+      }
+      throw new Error(errorMessage);
+    }
+    return response.json();
+  }
+  getTeamId() {
+    return this.config.projectId;
+  }
+  async getApiKey(forceRefresh = false) {
+    return this.resolveApiKey(forceRefresh);
+  }
+  getLlmGatewayUrl() {
+    return getLlmGatewayUrl(this.baseUrl);
+  }
+  async getTask(taskId) {
+    const teamId = this.getTeamId();
+    return this.apiRequest(`/api/projects/${teamId}/tasks/${taskId}/`);
+  }
+  async getTaskRun(taskId, runId) {
+    const teamId = this.getTeamId();
+    return this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`
+    );
+  }
+  async updateTaskRun(taskId, runId, payload) {
+    const teamId = this.getTeamId();
+    return this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(payload)
+      }
+    );
+  }
+  async setTaskRunOutput(taskId, runId, output) {
+    return this.apiRequest(
+      `/api/projects/${this.getTeamId()}/tasks/${taskId}/runs/${runId}/set_output/`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(output)
+      }
+    );
+  }
+  async appendTaskRunLog(taskId, runId, entries) {
+    const teamId = this.getTeamId();
+    return this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/append_log/`,
+      {
+        method: "POST",
+        body: JSON.stringify({ entries })
+      }
+    );
+  }
+  async relayMessage(taskId, runId, text2) {
+    const teamId = this.getTeamId();
+    await this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/relay_message/`,
+      {
+        method: "POST",
+        body: JSON.stringify({ text: text2 })
+      }
+    );
+  }
+  async uploadTaskArtifacts(taskId, runId, artifacts) {
+    if (!artifacts.length) {
+      return [];
+    }
+    const teamId = this.getTeamId();
+    const response = await this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/artifacts/`,
+      {
+        method: "POST",
+        body: JSON.stringify({ artifacts })
+      }
+    );
+    const manifest = response.artifacts ?? [];
+    return manifest.slice(-artifacts.length);
+  }
+  /**
+   * Download artifact content by storage path
+   * Streams the file through the PostHog backend so the sandbox does not need
+   * direct access to object storage.
+   */
+  async downloadArtifact(taskId, runId, storagePath) {
+    const teamId = this.getTeamId();
+    try {
+      const response = await this.performRequestWithRetry(
+        `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/artifacts/download/`,
+        {
+          method: "POST",
+          body: JSON.stringify({ storage_path: storagePath })
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`Failed to download artifact: ${response.status}`);
+      }
+      return response.arrayBuffer();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Fetch logs for a task run via the logs API endpoint
+   * @param taskRun - The task run to fetch logs for
+   * @returns Array of stored entries, or empty array if no logs available
+   */
+  async fetchTaskRunLogs(taskRun) {
+    const teamId = this.getTeamId();
+    const endpoint = `/api/projects/${teamId}/tasks/${taskRun.task}/runs/${taskRun.id}/logs`;
+    try {
+      const response = await this.performRequestWithRetry(endpoint);
+      if (!response.ok) {
+        if (response.status === 404) {
+          return [];
+        }
+        throw new Error(
+          `Failed to fetch logs: ${response.status} ${response.statusText}`
+        );
+      }
+      const content = await response.text();
+      if (!content.trim()) {
+        return [];
+      }
+      return content.trim().split("\n").map((line) => JSON.parse(line));
+    } catch (error) {
+      throw new Error(
+        `Failed to fetch task run logs: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+};
+
+// 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";
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_MAX_TOKENS = 15e4;
+function estimateTurnTokens(turn) {
+  let chars = 0;
+  for (const block of turn.content) {
+    if ("text" in block && typeof block.text === "string") {
+      chars += block.text.length;
+    }
+  }
+  if (turn.toolCalls) {
+    for (const tc of turn.toolCalls) {
+      chars += JSON.stringify(tc.input ?? "").length;
+      if (tc.result !== void 0) {
+        chars += typeof tc.result === "string" ? tc.result.length : JSON.stringify(tc.result).length;
+      }
+    }
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function selectRecentTurns(turns, maxTokens = DEFAULT_MAX_TOKENS) {
+  let budget = maxTokens;
+  let startIndex = turns.length;
+  for (let i2 = turns.length - 1; i2 >= 0; i2--) {
+    const cost = estimateTurnTokens(turns[i2]);
+    if (cost > budget) break;
+    budget -= cost;
+    startIndex = i2;
+  }
+  while (startIndex < turns.length && turns[startIndex].role !== "user") {
+    startIndex++;
+  }
+  return turns.slice(startIndex);
+}
+
+// src/sagas/apply-snapshot-saga.ts
+import { mkdir as mkdir7, rm as rm6, writeFile as writeFile5 } from "fs/promises";
+import { join as join12 } from "path";
+
+// ../git/dist/sagas/tree.js
+import { existsSync as existsSync5 } from "fs";
+import * as fs12 from "fs/promises";
+import * as path15 from "path";
+import * as tar from "tar";
+var CaptureTreeSaga = class extends GitSaga {
+  sagaName = "CaptureTreeSaga";
+  tempIndexPath = null;
+  async executeGitOperations(input) {
+    const { baseDir, lastTreeHash, archivePath, signal } = input;
+    const tmpDir = path15.join(baseDir, ".git", "posthog-code-tmp");
+    await this.step({
+      name: "create_tmp_dir",
+      execute: () => fs12.mkdir(tmpDir, { recursive: true }),
+      rollback: async () => {
+      }
+    });
+    this.tempIndexPath = path15.join(tmpDir, `index-${Date.now()}`);
     const tempIndexGit = this.git.env({
       ...process.env,
       GIT_INDEX_FILE: this.tempIndexPath
@@ -18756,7 +19592,7 @@ var CaptureTreeSaga = class extends GitSaga {
       execute: () => tempIndexGit.raw(["read-tree", "HEAD"]),
       rollback: async () => {
         if (this.tempIndexPath) {
-          await fs11.rm(this.tempIndexPath, { force: true }).catch(() => {
+          await fs12.rm(this.tempIndexPath, { force: true }).catch(() => {
           });
         }
       }
@@ -18765,7 +19601,7 @@ var CaptureTreeSaga = class extends GitSaga {
     const treeHash = await this.readOnlyStep("write_tree", () => tempIndexGit.raw(["write-tree"]));
     if (lastTreeHash && treeHash === lastTreeHash) {
       this.log.debug("No changes since last capture", { treeHash });
-      await fs11.rm(this.tempIndexPath, { force: true }).catch(() => {
+      await fs12.rm(this.tempIndexPath, { force: true }).catch(() => {
       });
       return { snapshot: null, changed: false };
     }
@@ -18777,7 +19613,7 @@ var CaptureTreeSaga = class extends GitSaga {
       }
     });
     const changes = await this.readOnlyStep("get_changes", () => this.getChanges(this.git, baseCommit, treeHash));
-    await fs11.rm(this.tempIndexPath, { force: true }).catch(() => {
+    await fs12.rm(this.tempIndexPath, { force: true }).catch(() => {
     });
     const snapshot = {
       treeHash,
@@ -18801,15 +19637,15 @@ var CaptureTreeSaga = class extends GitSaga {
     if (filesToArchive.length === 0) {
       return void 0;
     }
-    const existingFiles = filesToArchive.filter((f) => existsSync5(path13.join(baseDir, f)));
+    const existingFiles = filesToArchive.filter((f) => existsSync5(path15.join(baseDir, f)));
     if (existingFiles.length === 0) {
       return void 0;
     }
     await this.step({
       name: "create_archive",
       execute: async () => {
-        const archiveDir = path13.dirname(archivePath);
-        await fs11.mkdir(archiveDir, { recursive: true });
+        const archiveDir = path15.dirname(archivePath);
+        await fs12.mkdir(archiveDir, { recursive: true });
         await tar.create({
           gzip: true,
           file: archivePath,
@@ -18817,7 +19653,7 @@ var CaptureTreeSaga = class extends GitSaga {
         }, existingFiles);
       },
       rollback: async () => {
-        await fs11.rm(archivePath, { force: true }).catch(() => {
+        await fs12.rm(archivePath, { force: true }).catch(() => {
         });
       }
     });
@@ -18917,9 +19753,9 @@ var ApplyTreeSaga = class extends GitSaga {
       const filesToExtract = changes.filter((c) => c.status !== "D").map((c) => c.path);
       await this.readOnlyStep("backup_existing_files", async () => {
         for (const filePath of filesToExtract) {
-          const fullPath = path13.join(baseDir, filePath);
+          const fullPath = path15.join(baseDir, filePath);
           try {
-            const content = await fs11.readFile(fullPath);
+            const content = await fs12.readFile(fullPath);
             this.fileBackups.set(filePath, content);
           } catch {
           }
@@ -18936,16 +19772,16 @@ var ApplyTreeSaga = class extends GitSaga {
         },
         rollback: async () => {
           for (const filePath of this.extractedFiles) {
-            const fullPath = path13.join(baseDir, filePath);
+            const fullPath = path15.join(baseDir, filePath);
             const backup = this.fileBackups.get(filePath);
             if (backup) {
-              const dir = path13.dirname(fullPath);
-              await fs11.mkdir(dir, { recursive: true }).catch(() => {
+              const dir = path15.dirname(fullPath);
+              await fs12.mkdir(dir, { recursive: true }).catch(() => {
               });
-              await fs11.writeFile(fullPath, backup).catch(() => {
+              await fs12.writeFile(fullPath, backup).catch(() => {
               });
             } else {
-              await fs11.rm(fullPath, { force: true }).catch(() => {
+              await fs12.rm(fullPath, { force: true }).catch(() => {
               });
             }
           }
@@ -18953,10 +19789,10 @@ var ApplyTreeSaga = class extends GitSaga {
       });
     }
     for (const change of changes.filter((c) => c.status === "D")) {
-      const fullPath = path13.join(baseDir, change.path);
+      const fullPath = path15.join(baseDir, change.path);
       const backupContent = await this.readOnlyStep(`backup_${change.path}`, async () => {
         try {
-          return await fs11.readFile(fullPath);
+          return await fs12.readFile(fullPath);
         } catch {
           return null;
         }
@@ -18964,15 +19800,15 @@ var ApplyTreeSaga = class extends GitSaga {
       await this.step({
         name: `delete_${change.path}`,
         execute: async () => {
-          await fs11.rm(fullPath, { force: true });
+          await fs12.rm(fullPath, { force: true });
           this.log.debug(`Deleted file: ${change.path}`);
         },
         rollback: async () => {
           if (backupContent) {
-            const dir = path13.dirname(fullPath);
-            await fs11.mkdir(dir, { recursive: true }).catch(() => {
+            const dir = path15.dirname(fullPath);
+            await fs12.mkdir(dir, { recursive: true }).catch(() => {
             });
-            await fs11.writeFile(fullPath, backupContent).catch(() => {
+            await fs12.writeFile(fullPath, backupContent).catch(() => {
             });
           }
         }
@@ -18995,18 +19831,18 @@ var ApplySnapshotSaga = class extends Saga {
   archivePath = null;
   async execute(input) {
     const { snapshot, repositoryPath, apiClient, taskId, runId } = input;
-    const tmpDir = join10(repositoryPath, ".posthog", "tmp");
+    const tmpDir = join12(repositoryPath, ".posthog", "tmp");
     if (!snapshot.archiveUrl) {
       throw new Error("Cannot apply snapshot: no archive URL");
     }
     const archiveUrl = snapshot.archiveUrl;
     await this.step({
       name: "create_tmp_dir",
-      execute: () => mkdir4(tmpDir, { recursive: true }),
+      execute: () => mkdir7(tmpDir, { recursive: true }),
       rollback: async () => {
       }
     });
-    const archivePath = join10(tmpDir, `${snapshot.treeHash}.tar.gz`);
+    const archivePath = join12(tmpDir, `${snapshot.treeHash}.tar.gz`);
     this.archivePath = archivePath;
     await this.step({
       name: "download_archive",
@@ -19021,11 +19857,18 @@ var ApplySnapshotSaga = class extends Saga {
         }
         const base64Content = Buffer.from(arrayBuffer).toString("utf-8");
         const binaryContent = Buffer.from(base64Content, "base64");
-        await writeFile4(archivePath, binaryContent);
+        await writeFile5(archivePath, binaryContent);
+        this.log.info("Tree archive downloaded", {
+          treeHash: snapshot.treeHash,
+          snapshotBytes: binaryContent.byteLength,
+          snapshotWireBytes: arrayBuffer.byteLength,
+          totalBytes: binaryContent.byteLength,
+          totalWireBytes: arrayBuffer.byteLength
+        });
       },
       rollback: async () => {
         if (this.archivePath) {
-          await rm3(this.archivePath, { force: true }).catch(() => {
+          await rm6(this.archivePath, { force: true }).catch(() => {
           });
         }
       }
@@ -19041,7 +19884,7 @@ var ApplySnapshotSaga = class extends Saga {
     if (!applyResult.success) {
       throw new Error(`Failed to apply tree: ${applyResult.error}`);
     }
-    await rm3(this.archivePath, { force: true }).catch(() => {
+    await rm6(this.archivePath, { force: true }).catch(() => {
     });
     this.log.info("Tree snapshot applied", {
       treeHash: snapshot.treeHash,
@@ -19054,8 +19897,8 @@ var ApplySnapshotSaga = class extends Saga {
 
 // src/sagas/capture-tree-saga.ts
 import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile4, rm as rm4 } from "fs/promises";
-import { join as join11 } from "path";
+import { readFile as readFile6, rm as rm7 } from "fs/promises";
+import { join as join13 } from "path";
 var CaptureTreeSaga2 = class extends Saga {
   sagaName = "CaptureTreeSaga";
   async execute(input) {
@@ -19067,14 +19910,14 @@ var CaptureTreeSaga2 = class extends Saga {
       taskId,
       runId
     } = input;
-    const tmpDir = join11(repositoryPath, ".posthog", "tmp");
-    if (existsSync6(join11(repositoryPath, ".gitmodules"))) {
+    const tmpDir = join13(repositoryPath, ".posthog", "tmp");
+    if (existsSync6(join13(repositoryPath, ".gitmodules"))) {
       this.log.warn(
         "Repository has submodules - snapshot may not capture submodule state"
       );
     }
     const shouldArchive = !!apiClient;
-    const archivePath = shouldArchive ? join11(tmpDir, `tree-${Date.now()}.tar.gz`) : void 0;
+    const archivePath = shouldArchive ? join13(tmpDir, `tree-${Date.now()}.tar.gz`) : void 0;
     const gitCaptureSaga = new CaptureTreeSaga(this.log);
     const captureResult = await gitCaptureSaga.run({
       baseDir: repositoryPath,
@@ -19104,7 +19947,7 @@ var CaptureTreeSaga2 = class extends Saga {
           runId
         );
       } finally {
-        await rm4(createdArchivePath, { force: true }).catch(() => {
+        await rm7(createdArchivePath, { force: true }).catch(() => {
         });
       }
     }
@@ -19128,8 +19971,10 @@ var CaptureTreeSaga2 = class extends Saga {
     const archiveUrl = await this.step({
       name: "upload_archive",
       execute: async () => {
-        const archiveContent = await readFile4(archivePath);
+        const archiveContent = await readFile6(archivePath);
         const base64Content = archiveContent.toString("base64");
+        const snapshotBytes = archiveContent.byteLength;
+        const snapshotWireBytes = Buffer.byteLength(base64Content, "utf-8");
         const artifacts = await apiClient.uploadTaskArtifacts(taskId, runId, [
           {
             name: `trees/${treeHash}.tar.gz`,
@@ -19138,17 +19983,22 @@ var CaptureTreeSaga2 = class extends Saga {
             content_type: "application/gzip"
           }
         ]);
-        if (artifacts.length > 0 && artifacts[0].storage_path) {
+        const uploadedArtifact = artifacts[0];
+        if (uploadedArtifact?.storage_path) {
           this.log.info("Tree archive uploaded", {
-            storagePath: artifacts[0].storage_path,
-            treeHash
+            storagePath: uploadedArtifact.storage_path,
+            treeHash,
+            snapshotBytes,
+            snapshotWireBytes,
+            totalBytes: snapshotBytes,
+            totalWireBytes: snapshotWireBytes
           });
-          return artifacts[0].storage_path;
+          return uploadedArtifact.storage_path;
         }
         return void 0;
       },
       rollback: async () => {
-        await rm4(archivePath, { force: true }).catch(() => {
+        await rm7(archivePath, { force: true }).catch(() => {
         });
       }
     });
@@ -19276,6 +20126,10 @@ var ResumeSaga = class extends Saga {
       "find_snapshot",
       () => Promise.resolve(this.findLatestTreeSnapshot(entries))
     );
+    const latestGitCheckpoint = await this.readOnlyStep(
+      "find_git_checkpoint",
+      () => Promise.resolve(this.findLatestGitCheckpoint(entries))
+    );
     let snapshotApplied = false;
     if (latestSnapshot?.archiveUrl && repositoryPath) {
       this.log.info("Found tree snapshot", {
@@ -19348,6 +20202,7 @@ var ResumeSaga = class extends Saga {
     return {
       conversation,
       latestSnapshot,
+      latestGitCheckpoint,
       snapshotApplied,
       interrupted: latestSnapshot?.interrupted ?? false,
       lastDevice,
@@ -19358,6 +20213,7 @@ var ResumeSaga = class extends Saga {
     return {
       conversation: [],
       latestSnapshot: null,
+      latestGitCheckpoint: null,
       snapshotApplied: false,
       interrupted: false,
       logEntryCount: 0
@@ -19378,6 +20234,20 @@ var ResumeSaga = class extends Saga {
     }
     return null;
   }
+  findLatestGitCheckpoint(entries) {
+    const sdkPrefixedMethod = `_${POSTHOG_NOTIFICATIONS.GIT_CHECKPOINT}`;
+    for (let i2 = entries.length - 1; i2 >= 0; i2--) {
+      const entry = entries[i2];
+      const method = entry.notification?.method;
+      if (method === sdkPrefixedMethod || method === POSTHOG_NOTIFICATIONS.GIT_CHECKPOINT) {
+        const params = entry.notification?.params;
+        if (params?.checkpointId && params?.checkpointRef) {
+          return params;
+        }
+      }
+    }
+    return null;
+  }
   findLastDeviceInfo(entries) {
     for (let i2 = entries.length - 1; i2 >= 0; i2--) {
       const entry = entries[i2];
@@ -19526,6 +20396,7 @@ async function resumeFromLog(config) {
   return {
     conversation: result.data.conversation,
     latestSnapshot: result.data.latestSnapshot,
+    latestGitCheckpoint: result.data.latestGitCheckpoint,
     snapshotApplied: result.data.snapshotApplied,
     interrupted: result.data.interrupted,
     lastDevice: result.data.lastDevice,
@@ -19565,9 +20436,9 @@ ${toolSummary}`);
 }
 
 // src/session-log-writer.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import fsp from "fs/promises";
-import path14 from "path";
+import path16 from "path";
 var SessionLogWriter = class _SessionLogWriter {
   static FLUSH_DEBOUNCE_MS = 500;
   static FLUSH_MAX_INTERVAL_MS = 5e3;
@@ -19603,13 +20474,13 @@ var SessionLogWriter = class _SessionLogWriter {
     this.sessions.set(sessionId, { context, currentTurnMessages: [] });
     this.lastFlushAttemptTime.set(sessionId, Date.now());
     if (this.localCachePath) {
-      const sessionDir = path14.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,
@@ -19861,14 +20732,14 @@ var SessionLogWriter = class _SessionLogWriter {
     if (!this.localCachePath) return;
     const session = this.sessions.get(sessionId);
     if (!session) return;
-    const logPath = path14.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", {
@@ -19880,13 +20751,13 @@ var SessionLogWriter = class _SessionLogWriter {
     }
   }
   static async cleanupOldSessions(localCachePath) {
-    const sessionsDir = path14.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 = path14.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) {
@@ -19968,6 +20839,14 @@ var httpHeaderSchema = z3.object({
   name: z3.string(),
   value: z3.string()
 });
+var nullishString = z3.string().nullish().transform((value) => value ?? null);
+var handoffLocalGitStateSchema = z3.object({
+  head: nullishString,
+  branch: nullishString,
+  upstreamHead: nullishString,
+  upstreamRemote: nullishString,
+  upstreamMergeRef: nullishString
+});
 var remoteMcpServerSchema = z3.object({
   type: z3.enum(["http", "sse"]),
   name: z3.string().min(1, "MCP server name is required"),
@@ -20019,13 +20898,16 @@ var setConfigOptionParamsSchema = z3.object({
 var refreshSessionParamsSchema = z3.object({
   mcpServers: mcpServersSchema
 });
+var closeParamsSchema = z3.object({
+  localGitState: handoffLocalGitStateSchema.optional()
+}).optional();
 var commandParamsSchemas = {
   user_message: userMessageParamsSchema,
   "posthog/user_message": userMessageParamsSchema,
   cancel: z3.object({}).optional(),
   "posthog/cancel": z3.object({}).optional(),
-  close: z3.object({}).optional(),
-  "posthog/close": z3.object({}).optional(),
+  close: closeParamsSchema,
+  "posthog/close": closeParamsSchema,
   permission_response: permissionResponseParamsSchema,
   "posthog/permission_response": permissionResponseParamsSchema,
   set_config_option: setConfigOptionParamsSchema,
@@ -20347,7 +21229,7 @@ var AgentServer = class {
     return app;
   }
   async start() {
-    await new Promise((resolve6) => {
+    await new Promise((resolve7) => {
       this.server = serve(
         {
           fetch: this.app.fetch,
@@ -20357,7 +21239,7 @@ var AgentServer = class {
           this.logger.debug(
             `HTTP server listening on port ${this.config.port}`
           );
-          resolve6();
+          resolve7();
         }
       );
     });
@@ -20511,6 +21393,10 @@ var AgentServer = class {
       case POSTHOG_NOTIFICATIONS.CLOSE:
       case "close": {
         this.logger.debug("Close requested");
+        const localGitState = this.extractHandoffLocalGitState(params);
+        if (localGitState && this.session) {
+          this.session.pendingHandoffGitState = localGitState;
+        }
         await this.cleanupSession();
         return { closed: true };
       }
@@ -20737,7 +21623,8 @@ var AgentServer = class {
       deviceInfo,
       logWriter,
       permissionMode: initialPermissionMode,
-      hasDesktopConnected: sseController !== null
+      hasDesktopConnected: sseController !== null,
+      pendingHandoffGitState: void 0
     };
     this.logger = new Logger({
       debug: true,
@@ -21062,16 +21949,16 @@ 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 = join12(
+    const artifactDir = join14(
       this.config.repositoryPath ?? "/tmp/workspace",
       ".posthog",
       "attachments",
       runId,
       artifact.id ?? safeName
     );
-    await mkdir5(artifactDir, { recursive: true });
-    const artifactPath = join12(artifactDir, safeName);
-    await writeFile5(artifactPath, Buffer.from(data));
+    await mkdir8(artifactDir, { recursive: true });
+    const artifactPath = join14(artifactDir, safeName);
+    await writeFile6(artifactPath, Buffer.from(data));
     return resourceLink(pathToFileURL(artifactPath).toString(), artifact.name, {
       ...artifact.content_type ? { mimeType: artifact.content_type } : {},
       ...typeof artifact.size === "number" ? { size: artifact.size } : {}
@@ -21570,6 +22457,11 @@ ${attributionInstructions}
   async cleanupSession() {
     if (!this.session) return;
     this.logger.debug("Cleaning up session");
+    try {
+      await this.captureHandoffCheckpoint();
+    } catch (error) {
+      this.logger.error("Failed to capture handoff checkpoint", error);
+    }
     try {
       await this.captureTreeState();
     } catch (error) {
@@ -21629,6 +22521,50 @@ ${attributionInstructions}
       this.logger.error("Failed to capture tree state", error);
     }
   }
+  async captureHandoffCheckpoint() {
+    if (!this.session?.treeTracker || !this.session.pendingHandoffGitState) {
+      return;
+    }
+    if (!this.posthogAPI) {
+      this.logger.warn(
+        "Skipping handoff checkpoint capture: PostHog API client is not configured"
+      );
+      return;
+    }
+    const tracker = new HandoffCheckpointTracker({
+      repositoryPath: this.config.repositoryPath ?? "/tmp/workspace",
+      taskId: this.session.payload.task_id,
+      runId: this.session.payload.run_id,
+      apiClient: this.posthogAPI,
+      logger: this.logger.child("HandoffCheckpoint")
+    });
+    const checkpoint = await tracker.captureForHandoff(
+      this.session.pendingHandoffGitState
+    );
+    if (!checkpoint) return;
+    const checkpointWithDevice = {
+      ...checkpoint,
+      device: this.session.deviceInfo
+    };
+    const notification = {
+      jsonrpc: "2.0",
+      method: POSTHOG_NOTIFICATIONS.GIT_CHECKPOINT,
+      params: checkpointWithDevice
+    };
+    this.broadcastEvent({
+      type: "notification",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      notification
+    });
+    this.session.logWriter.appendRawLine(
+      this.session.payload.run_id,
+      JSON.stringify(notification)
+    );
+  }
+  extractHandoffLocalGitState(params) {
+    const result = handoffLocalGitStateSchema.safeParse(params.localGitState);
+    return result.success ? result.data : null;
+  }
   broadcastTurnComplete(stopReason) {
     if (!this.session) return;
     this.broadcastEvent({
@@ -21682,8 +22618,8 @@ ${attributionInstructions}
       options: params.options,
       toolCall: params.toolCall
     });
-    return new Promise((resolve6) => {
-      this.pendingPermissions.set(requestId, { resolve: resolve6 });
+    return new Promise((resolve7) => {
+      this.pendingPermissions.set(requestId, { resolve: resolve7 });
     });
   }
   resolvePermission(requestId, optionId, customInput, answers) {