@posthog/agent 2.3.386 → 2.3.388

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.388",
   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,660 +18507,1185 @@ 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 tempIndexGit = this.git.env({
-      ...process.env,
-      GIT_INDEX_FILE: this.tempIndexPath
-    });
-    await this.step({
-      name: "init_temp_index",
-      execute: () => tempIndexGit.raw(["read-tree", "HEAD"]),
-      rollback: async () => {
-        if (this.tempIndexPath) {
-          await fs11.rm(this.tempIndexPath, { force: true }).catch(() => {
-          });
-        }
-      }
-    });
-    await this.readOnlyStep("stage_files", () => tempIndexGit.raw(["add", "-A"]));
-    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(() => {
-      });
-      return { snapshot: null, changed: false };
-    }
-    const baseCommit = await this.readOnlyStep("get_base_commit", async () => {
+    const checkpointId = input.checkpointId ?? randomUUID2();
+    const refName = `${CHECKPOINT_REF_PREFIX}${checkpointId}`;
+    const existingRef = await this.readOnlyStep("check_existing_ref", async () => {
       try {
-        return await getHeadSha(baseDir, { abortSignal: signal });
+        await this.git.revparse(["--verify", refName]);
+        return true;
       } catch {
-        return null;
+        return false;
       }
     });
-    const changes = await this.readOnlyStep("get_changes", () => this.getChanges(this.git, baseCommit, treeHash));
-    await fs11.rm(this.tempIndexPath, { force: true }).catch(() => {
+    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(() => {
+        });
+      }
     });
-    const snapshot = {
-      treeHash,
-      baseCommit,
-      changes,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    return {
+      checkpointId,
+      commit: commitHash,
+      head: headInfo.head,
+      branch: headInfo.branch,
+      indexTree: indexTree.trim(),
+      worktreeTree: worktreeTree.trim(),
+      timestamp
     };
-    let createdArchivePath;
-    if (archivePath) {
-      createdArchivePath = await this.createArchive(baseDir, archivePath, changes);
+  }
+};
+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;
     }
-    this.log.info("Tree captured", {
-      treeHash,
-      changes: changes.length,
-      archived: !!createdArchivePath
+  };
+  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(() => {
     });
-    return { snapshot, archivePath: createdArchivePath, changed: true };
   }
-  async createArchive(baseDir, archivePath, changes) {
-    const filesToArchive = changes.filter((c) => c.status !== "D").map((c) => c.path);
-    if (filesToArchive.length === 0) {
-      return void 0;
+}
+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(() => {
+      });
     }
-    const existingFiles = filesToArchive.filter((f) => existsSync5(path13.join(baseDir, f)));
-    if (existingFiles.length === 0) {
-      return void 0;
+  }
+  async applyFromHandoff(input) {
+    const { checkpoint, headPackPath, indexPath, localGitState, onDivergedBranch } = input;
+    const git = createGitClient(this.repositoryPath);
+    if (headPackPath) {
+      await this.unpackPackFile(headPackPath);
     }
-    await this.step({
-      name: "create_archive",
-      execute: async () => {
-        const archiveDir = path13.dirname(archivePath);
-        await fs11.mkdir(archiveDir, { recursive: true });
-        await tar.create({
-          gzip: true,
-          file: archivePath,
-          cwd: baseDir
-        }, existingFiles);
-      },
-      rollback: async () => {
-        await fs11.rm(archivePath, { force: true }).catch(() => {
-        });
+    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 archivePath;
+    return { path: packPath, rawBytes };
   }
-  async getChanges(git, fromRef, toRef) {
-    if (!fromRef) {
-      const stdout2 = await git.raw(["ls-tree", "-r", "--name-only", toRef]);
-      return stdout2.split("\n").filter((p) => p.trim()).map((p) => ({ path: p, status: "A" }));
+  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
+      };
     }
-    const stdout = await git.raw([
-      "diff-tree",
-      "-r",
-      "--name-status",
-      fromRef,
-      toRef
-    ]);
-    const changes = [];
-    for (const line of stdout.split("\n")) {
-      if (!line.trim())
-        continue;
-      const [status, filePath] = line.split("	");
-      if (!filePath)
-        continue;
-      let normalizedStatus;
-      if (status === "D") {
-        normalizedStatus = "D";
-      } else if (status === "A") {
-        normalizedStatus = "A";
-      } else {
-        normalizedStatus = "M";
-      }
-      changes.push({ path: filePath, status: normalizedStatus });
+    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 changes;
+    return {
+      kind: "diverged",
+      divergence: {
+        branch,
+        localHead: nonAncestorHead,
+        cloudHead
+      }
+    };
   }
-};
-var ApplyTreeSaga = class extends GitSaga {
-  sagaName = "ApplyTreeSaga";
-  originalHead = null;
-  originalBranch = null;
-  extractedFiles = [];
-  fileBackups = /* @__PURE__ */ new Map();
-  async executeGitOperations(input) {
-    const { baseDir, treeHash, baseCommit, changes, archivePath } = input;
-    const headInfo = await this.readOnlyStep("get_current_head", async () => {
-      let head = null;
-      let branch = null;
-      try {
-        head = await this.git.revparse(["HEAD"]);
-      } catch {
-        head = null;
+  async findNonAncestorHead(_git, heads, cloudHead) {
+    for (const head of heads) {
+      if (head === cloudHead) {
+        continue;
       }
-      try {
-        branch = await this.git.raw(["symbolic-ref", "--short", "HEAD"]);
-      } catch {
-        branch = null;
+      if (!await this.isAncestor(head, cloudHead)) {
+        return head;
       }
-      return { head, branch };
-    });
-    this.originalHead = headInfo.head;
-    this.originalBranch = headInfo.branch;
-    let checkoutPerformed = false;
-    if (baseCommit && baseCommit !== this.originalHead) {
-      await this.readOnlyStep("check_working_tree", async () => {
-        const status = await this.git.status();
-        if (!status.isClean()) {
-          const changedFiles = status.modified.length + status.staged.length + status.deleted.length;
-          throw new Error(`Cannot apply tree: ${changedFiles} uncommitted change(s) exist. Commit or stash your changes first.`);
+    }
+    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);
       });
-      await this.step({
-        name: "checkout_base",
-        execute: async () => {
-          await this.git.checkout(baseCommit);
-          checkoutPerformed = true;
-          this.log.warn("Applied tree from different commit - now in detached HEAD state", {
-            originalHead: this.originalHead,
-            originalBranch: this.originalBranch,
-            baseCommit
-          });
-        },
-        rollback: async () => {
-          try {
-            if (this.originalBranch) {
-              await this.git.checkout(this.originalBranch);
-            } else if (this.originalHead) {
-              await this.git.checkout(this.originalHead);
-            }
-          } catch (error) {
-            this.log.warn("Failed to rollback checkout", { error });
-          }
+    });
+  }
+  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}`));
       });
-    }
-    if (archivePath) {
-      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);
-          try {
-            const content = await fs11.readFile(fullPath);
-            this.fileBackups.set(filePath, content);
-          } catch {
-          }
-        }
-      });
-      await this.step({
-        name: "extract_archive",
-        execute: async () => {
-          await tar.extract({
-            file: archivePath,
-            cwd: baseDir
-          });
-          this.extractedFiles = filesToExtract;
-        },
-        rollback: async () => {
-          for (const filePath of this.extractedFiles) {
-            const fullPath = path13.join(baseDir, filePath);
-            const backup = this.fileBackups.get(filePath);
-            if (backup) {
-              const dir = path13.dirname(fullPath);
-              await fs11.mkdir(dir, { recursive: true }).catch(() => {
-              });
-              await fs11.writeFile(fullPath, backup).catch(() => {
-              });
-            } else {
-              await fs11.rm(fullPath, { force: true }).catch(() => {
-              });
-            }
-          }
-        }
-      });
-    }
-    for (const change of changes.filter((c) => c.status === "D")) {
-      const fullPath = path13.join(baseDir, change.path);
-      const backupContent = await this.readOnlyStep(`backup_${change.path}`, async () => {
-        try {
-          return await fs11.readFile(fullPath);
-        } catch {
-          return null;
-        }
-      });
-      await this.step({
-        name: `delete_${change.path}`,
-        execute: async () => {
-          await fs11.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(() => {
-            });
-            await fs11.writeFile(fullPath, backupContent).catch(() => {
-            });
-          }
-        }
-      });
-    }
-    const deletedCount = changes.filter((c) => c.status === "D").length;
-    this.log.info("Tree applied", {
-      treeHash,
-      totalChanges: changes.length,
-      deletedFiles: deletedCount,
-      checkoutPerformed
+      child.stdin.end(input);
     });
-    return { treeHash, checkoutPerformed };
   }
 };
-
-// src/sagas/apply-snapshot-saga.ts
-var ApplySnapshotSaga = class extends Saga {
-  sagaName = "ApplySnapshotSaga";
-  archivePath = null;
-  async execute(input) {
-    const { snapshot, repositoryPath, apiClient, taskId, runId } = input;
-    const tmpDir = join10(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 }),
-      rollback: async () => {
-      }
-    });
-    const archivePath = join10(tmpDir, `${snapshot.treeHash}.tar.gz`);
-    this.archivePath = archivePath;
-    await this.step({
-      name: "download_archive",
-      execute: async () => {
-        const arrayBuffer = await apiClient.downloadArtifact(
-          taskId,
-          runId,
-          archiveUrl
-        );
-        if (!arrayBuffer) {
-          throw new Error("Failed to download archive");
-        }
-        const base64Content = Buffer.from(arrayBuffer).toString("utf-8");
-        const binaryContent = Buffer.from(base64Content, "base64");
-        await writeFile4(archivePath, binaryContent);
-      },
-      rollback: async () => {
-        if (this.archivePath) {
-          await rm3(this.archivePath, { force: true }).catch(() => {
-          });
-        }
-      }
-    });
-    const gitApplySaga = new ApplyTreeSaga(this.log);
-    const applyResult = await gitApplySaga.run({
-      baseDir: repositoryPath,
-      treeHash: snapshot.treeHash,
-      baseCommit: snapshot.baseCommit,
-      changes: snapshot.changes,
-      archivePath: this.archivePath
-    });
-    if (!applyResult.success) {
-      throw new Error(`Failed to apply tree: ${applyResult.error}`);
-    }
-    await rm3(this.archivePath, { force: true }).catch(() => {
-    });
-    this.log.info("Tree snapshot applied", {
-      treeHash: snapshot.treeHash,
-      totalChanges: snapshot.changes.length,
-      deletedFiles: snapshot.changes.filter((c) => c.status === "D").length
-    });
-    return { treeHash: snapshot.treeHash };
+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;
   }
-};
-
-// 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";
-var CaptureTreeSaga2 = class extends Saga {
-  sagaName = "CaptureTreeSaga";
-  async execute(input) {
-    const {
-      repositoryPath,
-      lastTreeHash,
-      interrupted,
-      apiClient,
-      taskId,
-      runId
-    } = input;
-    const tmpDir = join11(repositoryPath, ".posthog", "tmp");
-    if (existsSync6(join11(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 gitCaptureSaga = new CaptureTreeSaga(this.log);
-    const captureResult = await gitCaptureSaga.run({
-      baseDir: repositoryPath,
-      lastTreeHash,
-      archivePath
-    });
-    if (!captureResult.success) {
-      throw new Error(`Failed to capture tree: ${captureResult.error}`);
-    }
-    const {
-      snapshot: gitSnapshot,
-      archivePath: createdArchivePath,
-      changed
-    } = captureResult.data;
-    if (!changed || !gitSnapshot) {
-      this.log.debug("No changes since last capture", { lastTreeHash });
-      return { snapshot: null, newTreeHash: lastTreeHash };
-    }
-    let archiveUrl;
-    if (apiClient && createdArchivePath) {
-      try {
-        archiveUrl = await this.uploadArchive(
-          createdArchivePath,
-          gitSnapshot.treeHash,
-          apiClient,
-          taskId,
-          runId
-        );
-      } finally {
-        await rm4(createdArchivePath, { force: true }).catch(() => {
-        });
-      }
-    }
-    const snapshot = {
-      treeHash: gitSnapshot.treeHash,
-      baseCommit: gitSnapshot.baseCommit,
-      changes: gitSnapshot.changes,
-      timestamp: gitSnapshot.timestamp,
-      interrupted,
-      archiveUrl
+}
+async function getTrackingMetadata(git, branch) {
+  if (!branch) {
+    return {
+      upstreamRemote: null,
+      upstreamMergeRef: null,
+      remoteUrl: null
     };
-    this.log.info("Tree captured", {
-      treeHash: snapshot.treeHash,
-      changes: snapshot.changes.length,
-      interrupted,
-      archiveUrl
-    });
-    return { snapshot, newTreeHash: snapshot.treeHash };
   }
-  async uploadArchive(archivePath, treeHash, apiClient, taskId, runId) {
-    const archiveUrl = await this.step({
-      name: "upload_archive",
-      execute: async () => {
-        const archiveContent = await readFile4(archivePath);
-        const base64Content = archiveContent.toString("base64");
-        const artifacts = await apiClient.uploadTaskArtifacts(taskId, runId, [
-          {
-            name: `trees/${treeHash}.tar.gz`,
-            type: "tree_snapshot",
-            content: base64Content,
-            content_type: "application/gzip"
-          }
-        ]);
-        if (artifacts.length > 0 && artifacts[0].storage_path) {
-          this.log.info("Tree archive uploaded", {
-            storagePath: artifacts[0].storage_path,
-            treeHash
-          });
-          return artifacts[0].storage_path;
-        }
-        return void 0;
-      },
-      rollback: async () => {
-        await rm4(archivePath, { force: true }).catch(() => {
-        });
-      }
-    });
-    return archiveUrl;
+  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/tree-tracker.ts
-var TreeTracker = class {
+// src/handoff-checkpoint.ts
+var HandoffCheckpointTracker = class {
   repositoryPath;
   taskId;
   runId;
   apiClient;
   logger;
-  lastTreeHash = null;
   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: "[TreeTracker]" });
+    this.logger = config.logger || new Logger({ debug: false, prefix: "[HandoffCheckpointTracker]" });
   }
-  /**
-   * Capture current working tree state as a snapshot.
-   * Uses a temporary index to avoid modifying user's staging area.
-   * Uses Saga pattern for atomic operation with automatic cleanup on failure.
-   */
-  async captureTree(options) {
-    const saga = new CaptureTreeSaga2(this.logger);
-    const result = await saga.run({
-      repositoryPath: this.repositoryPath,
-      taskId: this.taskId,
-      runId: this.runId,
-      apiClient: this.apiClient,
-      lastTreeHash: this.lastTreeHash,
-      interrupted: options?.interrupted
-    });
-    if (!result.success) {
-      this.logger.error("Failed to capture tree", {
-        error: result.error,
-        failedStep: result.failedStep
-      });
+  async captureForHandoff(localGitState) {
+    if (!this.apiClient) {
       throw new Error(
-        `Failed to capture tree at step '${result.failedStep}': ${result.error}`
+        "Cannot capture handoff checkpoint: API client not configured"
       );
     }
-    if (result.data.newTreeHash !== null) {
-      this.lastTreeHash = result.data.newTreeHash;
+    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);
     }
-    return result.data.snapshot;
   }
-  /**
-   * Download and apply a tree snapshot.
-   * Uses Saga pattern for atomic operation with rollback on failure.
-   */
-  async applyTreeSnapshot(snapshot) {
+  async applyFromHandoff(checkpoint, options) {
     if (!this.apiClient) {
-      throw new Error("Cannot apply snapshot: API client not configured");
-    }
-    if (!snapshot.archiveUrl) {
-      this.logger.warn("Cannot apply snapshot: no archive URL", {
-        treeHash: snapshot.treeHash,
-        changes: snapshot.changes.length
-      });
-      throw new Error("Cannot apply snapshot: no archive URL");
-    }
-    const saga = new ApplySnapshotSaga(this.logger);
-    const result = await saga.run({
-      snapshot,
-      repositoryPath: this.repositoryPath,
-      apiClient: this.apiClient,
-      taskId: this.taskId,
-      runId: this.runId
-    });
-    if (!result.success) {
-      this.logger.error("Failed to apply tree snapshot", {
-        error: result.error,
-        failedStep: result.failedStep,
-        treeHash: snapshot.treeHash
-      });
       throw new Error(
-        `Failed to apply snapshot at step '${result.failedStep}': ${result.error}`
+        "Cannot apply handoff checkpoint: API client not configured"
       );
     }
-    this.lastTreeHash = result.data.treeHash;
-  }
-  /**
-   * Get the last captured tree hash.
-   */
-  getLastTreeHash() {
-    return this.lastTreeHash;
-  }
-  /**
-   * Set the last tree hash (used when resuming).
-   */
-  setLastTreeHash(hash) {
-    this.lastTreeHash = hash;
-  }
-};
-
-// src/sagas/resume-saga.ts
-var ResumeSaga = class extends Saga {
-  sagaName = "ResumeSaga";
-  async execute(input) {
-    const { taskId, runId, repositoryPath, apiClient } = input;
-    const logger = input.logger || new Logger({ debug: false, prefix: "[Resume]" });
-    const taskRun = await this.readOnlyStep(
-      "fetch_task_run",
-      () => apiClient.getTaskRun(taskId, runId)
-    );
-    if (!taskRun.log_url) {
-      this.log.info("No log URL found, starting fresh");
-      return this.emptyResult();
-    }
-    const entries = await this.readOnlyStep(
-      "fetch_logs",
-      () => apiClient.fetchTaskRunLogs(taskRun)
-    );
-    if (entries.length === 0) {
-      this.log.info("No log entries found, starting fresh");
-      return this.emptyResult();
-    }
-    this.log.info("Fetched log entries", { count: entries.length });
-    const latestSnapshot = await this.readOnlyStep(
-      "find_snapshot",
-      () => Promise.resolve(this.findLatestTreeSnapshot(entries))
-    );
-    let snapshotApplied = false;
-    if (latestSnapshot?.archiveUrl && repositoryPath) {
-      this.log.info("Found tree snapshot", {
-        treeHash: latestSnapshot.treeHash,
-        hasArchiveUrl: true,
-        changes: latestSnapshot.changes?.length ?? 0,
-        interrupted: latestSnapshot.interrupted
-      });
-      await this.step({
-        name: "apply_snapshot",
-        execute: async () => {
-          const treeTracker = new TreeTracker({
-            repositoryPath,
-            taskId,
-            runId,
-            apiClient,
-            logger: logger.child("TreeTracker")
-          });
-          try {
-            await treeTracker.applyTreeSnapshot(latestSnapshot);
-            treeTracker.setLastTreeHash(latestSnapshot.treeHash);
-            snapshotApplied = true;
-            this.log.info("Tree snapshot applied successfully", {
-              treeHash: latestSnapshot.treeHash
-            });
-          } catch (error) {
-            this.log.warn(
-              "Failed to apply tree snapshot, continuing without it",
-              {
-                error: error instanceof Error ? error.message : String(error),
-                treeHash: latestSnapshot.treeHash
-              }
-            );
-          }
+    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"
         },
-        rollback: async () => {
-        }
-      });
-    } else if (latestSnapshot?.archiveUrl && !repositoryPath) {
-      this.log.warn(
-        "Snapshot found but no repositoryPath configured - files cannot be restored",
         {
-          treeHash: latestSnapshot.treeHash,
-          changes: latestSnapshot.changes?.length ?? 0
+          key: "index",
+          storagePath: checkpoint.indexArtifactPath,
+          filePath: indexPath,
+          label: "handoff index"
         }
-      );
-    } else if (latestSnapshot) {
-      this.log.warn(
-        "Snapshot found but has no archive URL - files cannot be restored",
+      ]);
+      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);
+      return {
+        packBytes: downloads.pack?.rawBytes ?? 0,
+        indexBytes: downloads.index?.rawBytes ?? 0,
+        totalBytes: 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,
+      [
         {
-          treeHash: latestSnapshot.treeHash,
-          changes: latestSnapshot.changes?.length ?? 0
+          name: name2,
+          type: "artifact",
+          content: base64Content,
+          content_type: contentType
         }
-      );
-    }
-    const conversation = await this.readOnlyStep(
-      "rebuild_conversation",
-      () => Promise.resolve(this.rebuildConversation(entries))
-    );
-    const lastDevice = await this.readOnlyStep(
-      "find_device",
-      () => Promise.resolve(this.findLastDeviceInfo(entries))
+      ]
     );
-    this.log.info("Resume state rebuilt", {
-      turns: conversation.length,
-      hasSnapshot: !!latestSnapshot,
-      snapshotApplied,
-      interrupted: latestSnapshot?.interrupted ?? false
-    });
     return {
-      conversation,
-      latestSnapshot,
-      snapshotApplied,
-      interrupted: latestSnapshot?.interrupted ?? false,
-      lastDevice,
-      logEntryCount: entries.length
+      storagePath: artifacts.at(-1)?.storage_path,
+      rawBytes: content.byteLength,
+      wireBytes: Buffer.byteLength(base64Content, "utf-8")
     };
   }
-  emptyResult() {
+  async uploadArtifacts(specs) {
+    const results = [];
+    for (const spec of specs) {
+      if (!spec.filePath) {
+        results.push([spec.key, void 0]);
+        continue;
+      }
+      results.push([
+        spec.key,
+        await this.uploadArtifactFile(
+          spec.filePath,
+          spec.name,
+          spec.contentType
+        )
+      ]);
+    }
+    return Object.fromEntries(results);
+  }
+  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} from ${artifactPath}`);
+    }
+    const base64Content = Buffer.from(arrayBuffer).toString("utf-8");
+    const binaryContent = Buffer.from(base64Content, "base64");
+    await writeFile2(filePath, binaryContent);
     return {
-      conversation: [],
-      latestSnapshot: null,
-      snapshotApplied: false,
-      interrupted: false,
-      logEntryCount: 0
+      filePath,
+      rawBytes: binaryContent.byteLength,
+      wireBytes: arrayBuffer.byteLength
     };
   }
-  findLatestTreeSnapshot(entries) {
-    for (let i2 = entries.length - 1; i2 >= 0; i2--) {
-      const entry = entries[i2];
-      if (isNotification(
-        entry.notification?.method,
-        POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT
-      )) {
-        const params = entry.notification.params;
-        if (params?.treeHash) {
-          return params;
+  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;
     }
-    return null;
+    await rm4(filePath, { force: true }).catch(() => {
+    });
   }
-  findLastDeviceInfo(entries) {
-    for (let i2 = entries.length - 1; i2 >= 0; i2--) {
-      const entry = entries[i2];
-      const params = entry.notification?.params;
-      if (params?.device) {
-        return params.device;
+};
+
+// 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 void 0;
+    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 resumeRunInCloud(taskId, runId) {
+    const teamId = this.getTeamId();
+    return this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/resume_in_cloud/`,
+      { method: "POST" }
+    );
+  }
+  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/resume-saga.ts
+var ResumeSaga = class extends Saga {
+  sagaName = "ResumeSaga";
+  async execute(input) {
+    const { taskId, runId, apiClient } = input;
+    const taskRun = await this.readOnlyStep(
+      "fetch_task_run",
+      () => apiClient.getTaskRun(taskId, runId)
+    );
+    if (!taskRun.log_url) {
+      this.log.info("No log URL found, starting fresh");
+      return this.emptyResult();
+    }
+    const entries = await this.readOnlyStep(
+      "fetch_logs",
+      () => apiClient.fetchTaskRunLogs(taskRun)
+    );
+    if (entries.length === 0) {
+      this.log.info("No log entries found, starting fresh");
+      return this.emptyResult();
+    }
+    this.log.info("Fetched log entries", { count: entries.length });
+    const latestSnapshot = await this.readOnlyStep(
+      "find_snapshot",
+      () => Promise.resolve(this.findLatestTreeSnapshot(entries))
+    );
+    const latestGitCheckpoint = await this.readOnlyStep(
+      "find_git_checkpoint",
+      () => Promise.resolve(this.findLatestGitCheckpoint(entries))
+    );
+    if (latestSnapshot) {
+      this.log.info("Found tree snapshot", {
+        treeHash: latestSnapshot.treeHash,
+        hasArchiveUrl: !!latestSnapshot.archiveUrl,
+        changes: latestSnapshot.changes?.length ?? 0
+      });
+    }
+    if (latestGitCheckpoint) {
+      this.log.info("Found git checkpoint", {
+        checkpointId: latestGitCheckpoint.checkpointId,
+        branch: latestGitCheckpoint.branch
+      });
+    }
+    const conversation = await this.readOnlyStep(
+      "rebuild_conversation",
+      () => Promise.resolve(this.rebuildConversation(entries))
+    );
+    const lastDevice = await this.readOnlyStep(
+      "find_device",
+      () => Promise.resolve(this.findLastDeviceInfo(entries))
+    );
+    this.log.info("Resume state rebuilt", {
+      turns: conversation.length,
+      hasSnapshot: !!latestSnapshot,
+      hasGitCheckpoint: !!latestGitCheckpoint,
+      interrupted: latestSnapshot?.interrupted ?? false
+    });
+    return {
+      conversation,
+      latestSnapshot,
+      latestGitCheckpoint,
+      interrupted: latestSnapshot?.interrupted ?? false,
+      lastDevice,
+      logEntryCount: entries.length
+    };
+  }
+  emptyResult() {
+    return {
+      conversation: [],
+      latestSnapshot: null,
+      latestGitCheckpoint: null,
+      interrupted: false,
+      logEntryCount: 0
+    };
+  }
+  findLatestTreeSnapshot(entries) {
+    for (let i2 = entries.length - 1; i2 >= 0; i2--) {
+      const entry = entries[i2];
+      if (isNotification(
+        entry.notification?.method,
+        POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT
+      )) {
+        const params = entry.notification.params;
+        if (params?.treeHash) {
+          return params;
+        }
+      }
+    }
+    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];
+      const params = entry.notification?.params;
+      if (params?.device) {
+        return params.device;
+      }
+    }
+    return void 0;
   }
   rebuildConversation(entries) {
     const turns = [];
@@ -19442,463 +19741,1012 @@ var ResumeSaga = class extends Saga {
             }
             break;
           }
-          case "tool_call":
-          case "tool_call_update": {
-            const meta = update._meta?.claudeCode;
-            if (meta) {
-              const toolCallId = meta.toolCallId;
-              const toolName = meta.toolName;
-              const toolInput = meta.toolInput;
-              const toolResponse = meta.toolResponse;
-              if (toolCallId && toolName) {
-                let toolCall = currentToolCalls.find(
-                  (tc) => tc.toolCallId === toolCallId
-                );
-                if (!toolCall) {
-                  toolCall = {
-                    toolCallId,
-                    toolName,
-                    input: toolInput
-                  };
-                  currentToolCalls.push(toolCall);
-                }
-                if (toolResponse !== void 0) {
-                  toolCall.result = toolResponse;
-                }
-              }
-            }
-            break;
+          case "tool_call":
+          case "tool_call_update": {
+            const meta = update._meta?.claudeCode;
+            if (meta) {
+              const toolCallId = meta.toolCallId;
+              const toolName = meta.toolName;
+              const toolInput = meta.toolInput;
+              const toolResponse = meta.toolResponse;
+              if (toolCallId && toolName) {
+                let toolCall = currentToolCalls.find(
+                  (tc) => tc.toolCallId === toolCallId
+                );
+                if (!toolCall) {
+                  toolCall = {
+                    toolCallId,
+                    toolName,
+                    input: toolInput
+                  };
+                  currentToolCalls.push(toolCall);
+                }
+                if (toolResponse !== void 0) {
+                  toolCall.result = toolResponse;
+                }
+              }
+            }
+            break;
+          }
+          case "tool_result": {
+            const meta = update._meta?.claudeCode;
+            if (meta) {
+              const toolCallId = meta.toolCallId;
+              const toolResponse = meta.toolResponse;
+              if (toolCallId) {
+                const toolCall = currentToolCalls.find(
+                  (tc) => tc.toolCallId === toolCallId
+                );
+                if (toolCall && toolResponse !== void 0) {
+                  toolCall.result = toolResponse;
+                }
+              }
+            }
+            break;
+          }
+        }
+      }
+    }
+    if (currentAssistantContent.length > 0 || currentToolCalls.length > 0) {
+      turns.push({
+        role: "assistant",
+        content: currentAssistantContent,
+        toolCalls: currentToolCalls.length > 0 ? currentToolCalls : void 0
+      });
+    }
+    return turns;
+  }
+};
+
+// src/resume.ts
+async function resumeFromLog(config) {
+  const logger = config.logger || new Logger({ debug: false, prefix: "[Resume]" });
+  logger.info("Resuming from log", {
+    taskId: config.taskId,
+    runId: config.runId
+  });
+  const saga = new ResumeSaga(logger);
+  const result = await saga.run({
+    taskId: config.taskId,
+    runId: config.runId,
+    repositoryPath: config.repositoryPath,
+    apiClient: config.apiClient,
+    logger
+  });
+  if (!result.success) {
+    logger.error("Failed to resume from log", {
+      error: result.error,
+      failedStep: result.failedStep
+    });
+    throw new Error(
+      `Failed to resume at step '${result.failedStep}': ${result.error}`
+    );
+  }
+  return {
+    conversation: result.data.conversation,
+    latestSnapshot: result.data.latestSnapshot,
+    latestGitCheckpoint: result.data.latestGitCheckpoint,
+    interrupted: result.data.interrupted,
+    lastDevice: result.data.lastDevice,
+    logEntryCount: result.data.logEntryCount
+  };
+}
+var RESUME_HISTORY_TOKEN_BUDGET = 5e4;
+var TOOL_RESULT_MAX_CHARS = 2e3;
+var RESUME_CONTEXT_MARKERS = [
+  "You are resuming a previous conversation",
+  "Here is the conversation history from the",
+  "Continue from where you left off"
+];
+function isResumeContextTurn(turn) {
+  if (turn.role !== "user") return false;
+  const text2 = turn.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+  return RESUME_CONTEXT_MARKERS.some((marker) => text2.includes(marker));
+}
+function formatConversationForResume(conversation) {
+  const filtered = conversation.filter((turn) => !isResumeContextTurn(turn));
+  const selected = selectRecentTurns(filtered, RESUME_HISTORY_TOKEN_BUDGET);
+  const parts2 = [];
+  if (selected.length < filtered.length) {
+    parts2.push(
+      `*(${filtered.length - selected.length} earlier turns omitted)*`
+    );
+  }
+  for (const turn of selected) {
+    const role = turn.role === "user" ? "User" : "Assistant";
+    const textParts = turn.content.filter((block) => block.type === "text").map((block) => block.text);
+    if (textParts.length > 0) {
+      parts2.push(`**${role}**: ${textParts.join("\n")}`);
+    }
+    if (turn.toolCalls?.length) {
+      const toolSummary = turn.toolCalls.map((tc) => {
+        let resultStr = "";
+        if (tc.result !== void 0) {
+          const raw = typeof tc.result === "string" ? tc.result : JSON.stringify(tc.result);
+          resultStr = raw.length > TOOL_RESULT_MAX_CHARS ? ` \u2192 ${raw.substring(0, TOOL_RESULT_MAX_CHARS)}...(truncated)` : ` \u2192 ${raw}`;
+        }
+        return `  - ${tc.toolName}${resultStr}`;
+      }).join("\n");
+      parts2.push(`**${role} (tools)**:
+${toolSummary}`);
+    }
+  }
+  return parts2.join("\n\n");
+}
+
+// src/session-log-writer.ts
+import fs12 from "fs";
+import fsp from "fs/promises";
+import path15 from "path";
+var SessionLogWriter = class _SessionLogWriter {
+  static FLUSH_DEBOUNCE_MS = 500;
+  static FLUSH_MAX_INTERVAL_MS = 5e3;
+  static MAX_FLUSH_RETRIES = 10;
+  static MAX_RETRY_DELAY_MS = 3e4;
+  static SESSIONS_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+  posthogAPI;
+  pendingEntries = /* @__PURE__ */ new Map();
+  flushTimeouts = /* @__PURE__ */ new Map();
+  lastFlushAttemptTime = /* @__PURE__ */ new Map();
+  retryCounts = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  flushQueues = /* @__PURE__ */ new Map();
+  logger;
+  localCachePath;
+  constructor(options = {}) {
+    this.posthogAPI = options.posthogAPI;
+    this.localCachePath = options.localCachePath;
+    this.logger = options.logger ?? new Logger({ debug: false, prefix: "[SessionLogWriter]" });
+  }
+  async flushAll() {
+    const flushPromises = [];
+    for (const [sessionId, session] of this.sessions) {
+      this.emitCoalescedMessage(sessionId, session);
+      flushPromises.push(this.flush(sessionId));
+    }
+    await Promise.all(flushPromises);
+  }
+  register(sessionId, context) {
+    if (this.sessions.has(sessionId)) {
+      return;
+    }
+    this.sessions.set(sessionId, { context, currentTurnMessages: [] });
+    this.lastFlushAttemptTime.set(sessionId, Date.now());
+    if (this.localCachePath) {
+      const sessionDir = path15.join(
+        this.localCachePath,
+        "sessions",
+        context.runId
+      );
+      try {
+        fs12.mkdirSync(sessionDir, { recursive: true });
+      } catch (error) {
+        this.logger.warn("Failed to create local cache directory", {
+          sessionDir,
+          error
+        });
+      }
+    }
+  }
+  isRegistered(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  appendRawLine(sessionId, line) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      this.logger.warn("appendRawLine called for unregistered session", {
+        sessionId
+      });
+      return;
+    }
+    try {
+      const message = JSON.parse(line);
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      if (this.isAgentMessageChunk(message)) {
+        const text2 = this.extractChunkText(message);
+        if (text2) {
+          if (!session.chunkBuffer) {
+            session.chunkBuffer = { text: text2, firstTimestamp: timestamp };
+          } else {
+            session.chunkBuffer.text += text2;
+          }
+        }
+        return;
+      }
+      if (this.isDirectAgentMessage(message) && session.chunkBuffer) {
+        session.chunkBuffer = void 0;
+      } else {
+        this.emitCoalescedMessage(sessionId, session);
+      }
+      const nonChunkAgentText = this.extractAgentMessageText(message);
+      if (nonChunkAgentText) {
+        session.lastAgentMessage = nonChunkAgentText;
+        session.currentTurnMessages.push(nonChunkAgentText);
+      }
+      const entry = {
+        type: "notification",
+        timestamp,
+        notification: message
+      };
+      this.writeToLocalCache(sessionId, entry);
+      if (this.posthogAPI) {
+        const pending = this.pendingEntries.get(sessionId) ?? [];
+        pending.push(entry);
+        this.pendingEntries.set(sessionId, pending);
+        this.scheduleFlush(sessionId);
+      }
+    } catch {
+      this.logger.warn("Failed to parse raw line for persistence", {
+        taskId: session.context.taskId,
+        runId: session.context.runId,
+        lineLength: line.length
+      });
+    }
+  }
+  async flush(sessionId, { coalesce = false } = {}) {
+    if (coalesce) {
+      const session = this.sessions.get(sessionId);
+      if (session) {
+        this.emitCoalescedMessage(sessionId, session);
+      }
+    }
+    const prev = this.flushQueues.get(sessionId) ?? Promise.resolve();
+    const next = prev.catch(() => {
+    }).then(() => this._doFlush(sessionId));
+    this.flushQueues.set(sessionId, next);
+    next.finally(() => {
+      if (this.flushQueues.get(sessionId) === next) {
+        this.flushQueues.delete(sessionId);
+      }
+    });
+    return next;
+  }
+  async _doFlush(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      this.logger.warn("flush: no session found", { sessionId });
+      return;
+    }
+    const pending = this.pendingEntries.get(sessionId);
+    if (!this.posthogAPI || !pending?.length) {
+      return;
+    }
+    this.pendingEntries.delete(sessionId);
+    const timeout = this.flushTimeouts.get(sessionId);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.flushTimeouts.delete(sessionId);
+    }
+    this.lastFlushAttemptTime.set(sessionId, Date.now());
+    try {
+      await this.posthogAPI.appendTaskRunLog(
+        session.context.taskId,
+        session.context.runId,
+        pending
+      );
+      this.retryCounts.set(sessionId, 0);
+    } catch (error) {
+      const retryCount = (this.retryCounts.get(sessionId) ?? 0) + 1;
+      this.retryCounts.set(sessionId, retryCount);
+      if (retryCount >= _SessionLogWriter.MAX_FLUSH_RETRIES) {
+        this.logger.error(
+          `Dropping ${pending.length} session log entries after ${retryCount} failed flush attempts`,
+          {
+            taskId: session.context.taskId,
+            runId: session.context.runId,
+            error
           }
-          case "tool_result": {
-            const meta = update._meta?.claudeCode;
-            if (meta) {
-              const toolCallId = meta.toolCallId;
-              const toolResponse = meta.toolResponse;
-              if (toolCallId) {
-                const toolCall = currentToolCalls.find(
-                  (tc) => tc.toolCallId === toolCallId
-                );
-                if (toolCall && toolResponse !== void 0) {
-                  toolCall.result = toolResponse;
-                }
-              }
+        );
+        this.retryCounts.set(sessionId, 0);
+      } else {
+        if (retryCount === 1) {
+          this.logger.warn(
+            `Failed to persist session logs, will retry (up to ${_SessionLogWriter.MAX_FLUSH_RETRIES} attempts)`,
+            {
+              taskId: session.context.taskId,
+              runId: session.context.runId,
+              error: error instanceof Error ? error.message : String(error)
             }
-            break;
+          );
+        }
+        const currentPending = this.pendingEntries.get(sessionId) ?? [];
+        this.pendingEntries.set(sessionId, [...pending, ...currentPending]);
+        this.scheduleFlush(sessionId);
+      }
+    }
+  }
+  getSessionUpdateType(message) {
+    if (message.method !== "session/update") return void 0;
+    const params = message.params;
+    const update = params?.update;
+    return update?.sessionUpdate;
+  }
+  isDirectAgentMessage(message) {
+    return this.getSessionUpdateType(message) === "agent_message";
+  }
+  isAgentMessageChunk(message) {
+    return this.getSessionUpdateType(message) === "agent_message_chunk";
+  }
+  extractChunkText(message) {
+    const params = message.params;
+    const update = params?.update;
+    const content = update?.content;
+    if (content?.type === "text" && content.text) {
+      return content.text;
+    }
+    return "";
+  }
+  emitCoalescedMessage(sessionId, session) {
+    if (!session.chunkBuffer) return;
+    const { text: text2, firstTimestamp } = session.chunkBuffer;
+    session.chunkBuffer = void 0;
+    session.lastAgentMessage = text2;
+    session.currentTurnMessages.push(text2);
+    const entry = {
+      type: "notification",
+      timestamp: firstTimestamp,
+      notification: {
+        jsonrpc: "2.0",
+        method: "session/update",
+        params: {
+          update: {
+            sessionUpdate: "agent_message",
+            content: { type: "text", text: text2 }
           }
         }
       }
+    };
+    this.writeToLocalCache(sessionId, entry);
+    if (this.posthogAPI) {
+      const pending = this.pendingEntries.get(sessionId) ?? [];
+      pending.push(entry);
+      this.pendingEntries.set(sessionId, pending);
+      this.scheduleFlush(sessionId);
     }
-    if (currentAssistantContent.length > 0 || currentToolCalls.length > 0) {
-      turns.push({
-        role: "assistant",
-        content: currentAssistantContent,
-        toolCalls: currentToolCalls.length > 0 ? currentToolCalls : void 0
-      });
+  }
+  getLastAgentMessage(sessionId) {
+    return this.sessions.get(sessionId)?.lastAgentMessage;
+  }
+  getFullAgentResponse(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session || session.currentTurnMessages.length === 0) return void 0;
+    if (session.chunkBuffer) {
+      this.logger.warn(
+        "getFullAgentResponse called with non-empty chunk buffer",
+        {
+          sessionId,
+          bufferedLength: session.chunkBuffer.text.length
+        }
+      );
     }
-    return turns;
+    return session.currentTurnMessages.join("\n\n");
   }
-};
-
-// src/resume.ts
-async function resumeFromLog(config) {
-  const logger = config.logger || new Logger({ debug: false, prefix: "[Resume]" });
-  logger.info("Resuming from log", {
-    taskId: config.taskId,
-    runId: config.runId
-  });
-  const saga = new ResumeSaga(logger);
-  const result = await saga.run({
-    taskId: config.taskId,
-    runId: config.runId,
-    repositoryPath: config.repositoryPath,
-    apiClient: config.apiClient,
-    logger
-  });
-  if (!result.success) {
-    logger.error("Failed to resume from log", {
-      error: result.error,
-      failedStep: result.failedStep
-    });
-    throw new Error(
-      `Failed to resume at step '${result.failedStep}': ${result.error}`
-    );
+  resetTurnMessages(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.currentTurnMessages = [];
+    }
   }
-  return {
-    conversation: result.data.conversation,
-    latestSnapshot: result.data.latestSnapshot,
-    snapshotApplied: result.data.snapshotApplied,
-    interrupted: result.data.interrupted,
-    lastDevice: result.data.lastDevice,
-    logEntryCount: result.data.logEntryCount
-  };
-}
-var RESUME_HISTORY_TOKEN_BUDGET = 5e4;
-var TOOL_RESULT_MAX_CHARS = 2e3;
-function formatConversationForResume(conversation) {
-  const selected = selectRecentTurns(conversation, RESUME_HISTORY_TOKEN_BUDGET);
-  const parts2 = [];
-  if (selected.length < conversation.length) {
-    parts2.push(
-      `*(${conversation.length - selected.length} earlier turns omitted)*`
-    );
+  extractAgentMessageText(message) {
+    if (message.method !== "session/update") {
+      return null;
+    }
+    const params = message.params;
+    const update = params?.update;
+    if (update?.sessionUpdate !== "agent_message") {
+      return null;
+    }
+    const content = update.content;
+    if (content?.type === "text" && typeof content.text === "string") {
+      const trimmed2 = content.text.trim();
+      return trimmed2.length > 0 ? trimmed2 : null;
+    }
+    if (typeof update.message === "string") {
+      const trimmed2 = update.message.trim();
+      return trimmed2.length > 0 ? trimmed2 : null;
+    }
+    return null;
   }
-  for (const turn of selected) {
-    const role = turn.role === "user" ? "User" : "Assistant";
-    const textParts = turn.content.filter((block) => block.type === "text").map((block) => block.text);
-    if (textParts.length > 0) {
-      parts2.push(`**${role}**: ${textParts.join("\n")}`);
+  scheduleFlush(sessionId) {
+    const existing = this.flushTimeouts.get(sessionId);
+    if (existing) clearTimeout(existing);
+    const retryCount = this.retryCounts.get(sessionId) ?? 0;
+    const lastAttempt = this.lastFlushAttemptTime.get(sessionId) ?? 0;
+    const elapsed = Date.now() - lastAttempt;
+    let delay3;
+    if (retryCount > 0) {
+      delay3 = Math.min(
+        _SessionLogWriter.FLUSH_DEBOUNCE_MS * 2 ** retryCount,
+        _SessionLogWriter.MAX_RETRY_DELAY_MS
+      );
+    } else if (elapsed >= _SessionLogWriter.FLUSH_MAX_INTERVAL_MS) {
+      delay3 = 0;
+    } else {
+      delay3 = _SessionLogWriter.FLUSH_DEBOUNCE_MS;
     }
-    if (turn.toolCalls?.length) {
-      const toolSummary = turn.toolCalls.map((tc) => {
-        let resultStr = "";
-        if (tc.result !== void 0) {
-          const raw = typeof tc.result === "string" ? tc.result : JSON.stringify(tc.result);
-          resultStr = raw.length > TOOL_RESULT_MAX_CHARS ? ` \u2192 ${raw.substring(0, TOOL_RESULT_MAX_CHARS)}...(truncated)` : ` \u2192 ${raw}`;
+    const timeout = setTimeout(() => this.flush(sessionId), delay3);
+    this.flushTimeouts.set(sessionId, timeout);
+  }
+  writeToLocalCache(sessionId, entry) {
+    if (!this.localCachePath) return;
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    const logPath = path15.join(
+      this.localCachePath,
+      "sessions",
+      session.context.runId,
+      "logs.ndjson"
+    );
+    try {
+      fs12.appendFileSync(logPath, `${JSON.stringify(entry)}
+`);
+    } catch (error) {
+      this.logger.warn("Failed to write to local cache", {
+        taskId: session.context.taskId,
+        runId: session.context.runId,
+        logPath,
+        error
+      });
+    }
+  }
+  static async cleanupOldSessions(localCachePath) {
+    const sessionsDir = path15.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);
+        try {
+          const stats = await fsp.stat(entryPath);
+          if (stats.isDirectory() && now - stats.birthtimeMs > _SessionLogWriter.SESSIONS_MAX_AGE_MS) {
+            await fsp.rm(entryPath, { recursive: true, force: true });
+            deleted++;
+          }
+        } catch {
         }
-        return `  - ${tc.toolName}${resultStr}`;
-      }).join("\n");
-      parts2.push(`**${role} (tools)**:
-${toolSummary}`);
+      }
+    } catch {
     }
+    return deleted;
   }
-  return parts2.join("\n\n");
-}
+};
 
-// src/session-log-writer.ts
-import fs12 from "fs";
-import fsp from "fs/promises";
-import path14 from "path";
-var SessionLogWriter = class _SessionLogWriter {
-  static FLUSH_DEBOUNCE_MS = 500;
-  static FLUSH_MAX_INTERVAL_MS = 5e3;
-  static MAX_FLUSH_RETRIES = 10;
-  static MAX_RETRY_DELAY_MS = 3e4;
-  static SESSIONS_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
-  posthogAPI;
-  pendingEntries = /* @__PURE__ */ new Map();
-  flushTimeouts = /* @__PURE__ */ new Map();
-  lastFlushAttemptTime = /* @__PURE__ */ new Map();
-  retryCounts = /* @__PURE__ */ new Map();
-  sessions = /* @__PURE__ */ new Map();
-  flushQueues = /* @__PURE__ */ new Map();
-  logger;
-  localCachePath;
-  constructor(options = {}) {
-    this.posthogAPI = options.posthogAPI;
-    this.localCachePath = options.localCachePath;
-    this.logger = options.logger ?? new Logger({ debug: false, prefix: "[SessionLogWriter]" });
-  }
-  async flushAll() {
-    const flushPromises = [];
-    for (const [sessionId, session] of this.sessions) {
-      this.emitCoalescedMessage(sessionId, session);
-      flushPromises.push(this.flush(sessionId));
+// 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 fs13 from "fs/promises";
+import * as path16 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 = path16.join(baseDir, ".git", "posthog-code-tmp");
+    await this.step({
+      name: "create_tmp_dir",
+      execute: () => fs13.mkdir(tmpDir, { recursive: true }),
+      rollback: async () => {
+      }
+    });
+    this.tempIndexPath = path16.join(tmpDir, `index-${Date.now()}`);
+    const tempIndexGit = this.git.env({
+      ...process.env,
+      GIT_INDEX_FILE: this.tempIndexPath
+    });
+    await this.step({
+      name: "init_temp_index",
+      execute: () => tempIndexGit.raw(["read-tree", "HEAD"]),
+      rollback: async () => {
+        if (this.tempIndexPath) {
+          await fs13.rm(this.tempIndexPath, { force: true }).catch(() => {
+          });
+        }
+      }
+    });
+    await this.readOnlyStep("stage_files", () => tempIndexGit.raw(["add", "-A"]));
+    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 fs13.rm(this.tempIndexPath, { force: true }).catch(() => {
+      });
+      return { snapshot: null, changed: false };
+    }
+    const baseCommit = await this.readOnlyStep("get_base_commit", async () => {
+      try {
+        return await getHeadSha(baseDir, { abortSignal: signal });
+      } catch {
+        return null;
+      }
+    });
+    const changes = await this.readOnlyStep("get_changes", () => this.getChanges(this.git, baseCommit, treeHash));
+    await fs13.rm(this.tempIndexPath, { force: true }).catch(() => {
+    });
+    const snapshot = {
+      treeHash,
+      baseCommit,
+      changes,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    let createdArchivePath;
+    if (archivePath) {
+      createdArchivePath = await this.createArchive(baseDir, archivePath, changes);
     }
-    await Promise.all(flushPromises);
+    this.log.info("Tree captured", {
+      treeHash,
+      changes: changes.length,
+      archived: !!createdArchivePath
+    });
+    return { snapshot, archivePath: createdArchivePath, changed: true };
   }
-  register(sessionId, context) {
-    if (this.sessions.has(sessionId)) {
-      return;
+  async createArchive(baseDir, archivePath, changes) {
+    const filesToArchive = changes.filter((c) => c.status !== "D").map((c) => c.path);
+    if (filesToArchive.length === 0) {
+      return void 0;
     }
-    this.sessions.set(sessionId, { context, currentTurnMessages: [] });
-    this.lastFlushAttemptTime.set(sessionId, Date.now());
-    if (this.localCachePath) {
-      const sessionDir = path14.join(
-        this.localCachePath,
-        "sessions",
-        context.runId
-      );
-      try {
-        fs12.mkdirSync(sessionDir, { recursive: true });
-      } catch (error) {
-        this.logger.warn("Failed to create local cache directory", {
-          sessionDir,
-          error
+    const existingFiles = filesToArchive.filter((f) => existsSync5(path16.join(baseDir, f)));
+    if (existingFiles.length === 0) {
+      return void 0;
+    }
+    await this.step({
+      name: "create_archive",
+      execute: async () => {
+        const archiveDir = path16.dirname(archivePath);
+        await fs13.mkdir(archiveDir, { recursive: true });
+        await tar.create({
+          gzip: true,
+          file: archivePath,
+          cwd: baseDir
+        }, existingFiles);
+      },
+      rollback: async () => {
+        await fs13.rm(archivePath, { force: true }).catch(() => {
         });
       }
-    }
-  }
-  isRegistered(sessionId) {
-    return this.sessions.has(sessionId);
+    });
+    return archivePath;
   }
-  appendRawLine(sessionId, line) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      this.logger.warn("appendRawLine called for unregistered session", {
-        sessionId
-      });
-      return;
+  async getChanges(git, fromRef, toRef) {
+    if (!fromRef) {
+      const stdout2 = await git.raw(["ls-tree", "-r", "--name-only", toRef]);
+      return stdout2.split("\n").filter((p) => p.trim()).map((p) => ({ path: p, status: "A" }));
     }
-    try {
-      const message = JSON.parse(line);
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      if (this.isAgentMessageChunk(message)) {
-        const text2 = this.extractChunkText(message);
-        if (text2) {
-          if (!session.chunkBuffer) {
-            session.chunkBuffer = { text: text2, firstTimestamp: timestamp };
-          } else {
-            session.chunkBuffer.text += text2;
-          }
-        }
-        return;
-      }
-      if (this.isDirectAgentMessage(message) && session.chunkBuffer) {
-        session.chunkBuffer = void 0;
+    const stdout = await git.raw([
+      "diff-tree",
+      "-r",
+      "--name-status",
+      fromRef,
+      toRef
+    ]);
+    const changes = [];
+    for (const line of stdout.split("\n")) {
+      if (!line.trim())
+        continue;
+      const [status, filePath] = line.split("	");
+      if (!filePath)
+        continue;
+      let normalizedStatus;
+      if (status === "D") {
+        normalizedStatus = "D";
+      } else if (status === "A") {
+        normalizedStatus = "A";
       } else {
-        this.emitCoalescedMessage(sessionId, session);
+        normalizedStatus = "M";
       }
-      const nonChunkAgentText = this.extractAgentMessageText(message);
-      if (nonChunkAgentText) {
-        session.lastAgentMessage = nonChunkAgentText;
-        session.currentTurnMessages.push(nonChunkAgentText);
+      changes.push({ path: filePath, status: normalizedStatus });
+    }
+    return changes;
+  }
+};
+var ApplyTreeSaga = class extends GitSaga {
+  sagaName = "ApplyTreeSaga";
+  originalHead = null;
+  originalBranch = null;
+  extractedFiles = [];
+  fileBackups = /* @__PURE__ */ new Map();
+  async executeGitOperations(input) {
+    const { baseDir, treeHash, baseCommit, changes, archivePath } = input;
+    const headInfo = await this.readOnlyStep("get_current_head", async () => {
+      let head = null;
+      let branch = null;
+      try {
+        head = await this.git.revparse(["HEAD"]);
+      } catch {
+        head = null;
       }
-      const entry = {
-        type: "notification",
-        timestamp,
-        notification: message
-      };
-      this.writeToLocalCache(sessionId, entry);
-      if (this.posthogAPI) {
-        const pending = this.pendingEntries.get(sessionId) ?? [];
-        pending.push(entry);
-        this.pendingEntries.set(sessionId, pending);
-        this.scheduleFlush(sessionId);
+      try {
+        branch = await this.git.raw(["symbolic-ref", "--short", "HEAD"]);
+      } catch {
+        branch = null;
       }
-    } catch {
-      this.logger.warn("Failed to parse raw line for persistence", {
-        taskId: session.context.taskId,
-        runId: session.context.runId,
-        lineLength: line.length
+      return { head, branch };
+    });
+    this.originalHead = headInfo.head;
+    this.originalBranch = headInfo.branch;
+    let checkoutPerformed = false;
+    if (baseCommit && baseCommit !== this.originalHead) {
+      await this.readOnlyStep("check_working_tree", async () => {
+        const status = await this.git.status();
+        if (!status.isClean()) {
+          const changedFiles = status.modified.length + status.staged.length + status.deleted.length;
+          throw new Error(`Cannot apply tree: ${changedFiles} uncommitted change(s) exist. Commit or stash your changes first.`);
+        }
+      });
+      await this.step({
+        name: "checkout_base",
+        execute: async () => {
+          await this.git.checkout(baseCommit);
+          checkoutPerformed = true;
+          this.log.warn("Applied tree from different commit - now in detached HEAD state", {
+            originalHead: this.originalHead,
+            originalBranch: this.originalBranch,
+            baseCommit
+          });
+        },
+        rollback: async () => {
+          try {
+            if (this.originalBranch) {
+              await this.git.checkout(this.originalBranch);
+            } else if (this.originalHead) {
+              await this.git.checkout(this.originalHead);
+            }
+          } catch (error) {
+            this.log.warn("Failed to rollback checkout", { error });
+          }
+        }
+      });
+    }
+    if (archivePath) {
+      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 = path16.join(baseDir, filePath);
+          try {
+            const content = await fs13.readFile(fullPath);
+            this.fileBackups.set(filePath, content);
+          } catch {
+          }
+        }
+      });
+      await this.step({
+        name: "extract_archive",
+        execute: async () => {
+          await tar.extract({
+            file: archivePath,
+            cwd: baseDir
+          });
+          this.extractedFiles = filesToExtract;
+        },
+        rollback: async () => {
+          for (const filePath of this.extractedFiles) {
+            const fullPath = path16.join(baseDir, filePath);
+            const backup = this.fileBackups.get(filePath);
+            if (backup) {
+              const dir = path16.dirname(fullPath);
+              await fs13.mkdir(dir, { recursive: true }).catch(() => {
+              });
+              await fs13.writeFile(fullPath, backup).catch(() => {
+              });
+            } else {
+              await fs13.rm(fullPath, { force: true }).catch(() => {
+              });
+            }
+          }
+        }
+      });
+    }
+    for (const change of changes.filter((c) => c.status === "D")) {
+      const fullPath = path16.join(baseDir, change.path);
+      const backupContent = await this.readOnlyStep(`backup_${change.path}`, async () => {
+        try {
+          return await fs13.readFile(fullPath);
+        } catch {
+          return null;
+        }
+      });
+      await this.step({
+        name: `delete_${change.path}`,
+        execute: async () => {
+          await fs13.rm(fullPath, { force: true });
+          this.log.debug(`Deleted file: ${change.path}`);
+        },
+        rollback: async () => {
+          if (backupContent) {
+            const dir = path16.dirname(fullPath);
+            await fs13.mkdir(dir, { recursive: true }).catch(() => {
+            });
+            await fs13.writeFile(fullPath, backupContent).catch(() => {
+            });
+          }
+        }
       });
     }
+    const deletedCount = changes.filter((c) => c.status === "D").length;
+    this.log.info("Tree applied", {
+      treeHash,
+      totalChanges: changes.length,
+      deletedFiles: deletedCount,
+      checkoutPerformed
+    });
+    return { treeHash, checkoutPerformed };
   }
-  async flush(sessionId, { coalesce = false } = {}) {
-    if (coalesce) {
-      const session = this.sessions.get(sessionId);
-      if (session) {
-        this.emitCoalescedMessage(sessionId, session);
-      }
+};
+
+// src/sagas/apply-snapshot-saga.ts
+var ApplySnapshotSaga = class extends Saga {
+  sagaName = "ApplySnapshotSaga";
+  archivePath = null;
+  async execute(input) {
+    const { snapshot, repositoryPath, apiClient, taskId, runId } = input;
+    const tmpDir = join12(repositoryPath, ".posthog", "tmp");
+    if (!snapshot.archiveUrl) {
+      throw new Error("Cannot apply snapshot: no archive URL");
     }
-    const prev = this.flushQueues.get(sessionId) ?? Promise.resolve();
-    const next = prev.catch(() => {
-    }).then(() => this._doFlush(sessionId));
-    this.flushQueues.set(sessionId, next);
-    next.finally(() => {
-      if (this.flushQueues.get(sessionId) === next) {
-        this.flushQueues.delete(sessionId);
+    const archiveUrl = snapshot.archiveUrl;
+    await this.step({
+      name: "create_tmp_dir",
+      execute: () => mkdir7(tmpDir, { recursive: true }),
+      rollback: async () => {
       }
     });
-    return next;
+    const archivePath = join12(tmpDir, `${snapshot.treeHash}.tar.gz`);
+    this.archivePath = archivePath;
+    await this.step({
+      name: "download_archive",
+      execute: async () => {
+        const arrayBuffer = await apiClient.downloadArtifact(
+          taskId,
+          runId,
+          archiveUrl
+        );
+        if (!arrayBuffer) {
+          throw new Error("Failed to download archive");
+        }
+        const base64Content = Buffer.from(arrayBuffer).toString("utf-8");
+        const binaryContent = Buffer.from(base64Content, "base64");
+        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 rm6(this.archivePath, { force: true }).catch(() => {
+          });
+        }
+      }
+    });
+    const gitApplySaga = new ApplyTreeSaga(this.log);
+    const applyResult = await gitApplySaga.run({
+      baseDir: repositoryPath,
+      treeHash: snapshot.treeHash,
+      baseCommit: snapshot.baseCommit,
+      changes: snapshot.changes,
+      archivePath: this.archivePath
+    });
+    if (!applyResult.success) {
+      throw new Error(`Failed to apply tree: ${applyResult.error}`);
+    }
+    await rm6(this.archivePath, { force: true }).catch(() => {
+    });
+    this.log.info("Tree snapshot applied", {
+      treeHash: snapshot.treeHash,
+      totalChanges: snapshot.changes.length,
+      deletedFiles: snapshot.changes.filter((c) => c.status === "D").length
+    });
+    return { treeHash: snapshot.treeHash };
   }
-  async _doFlush(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      this.logger.warn("flush: no session found", { sessionId });
-      return;
+};
+
+// src/sagas/capture-tree-saga.ts
+import { existsSync as existsSync6 } from "fs";
+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) {
+    const {
+      repositoryPath,
+      lastTreeHash,
+      interrupted,
+      apiClient,
+      taskId,
+      runId
+    } = input;
+    const tmpDir = join13(repositoryPath, ".posthog", "tmp");
+    if (existsSync6(join13(repositoryPath, ".gitmodules"))) {
+      this.log.warn(
+        "Repository has submodules - snapshot may not capture submodule state"
+      );
     }
-    const pending = this.pendingEntries.get(sessionId);
-    if (!this.posthogAPI || !pending?.length) {
-      return;
+    const shouldArchive = !!apiClient;
+    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,
+      lastTreeHash,
+      archivePath
+    });
+    if (!captureResult.success) {
+      throw new Error(`Failed to capture tree: ${captureResult.error}`);
     }
-    this.pendingEntries.delete(sessionId);
-    const timeout = this.flushTimeouts.get(sessionId);
-    if (timeout) {
-      clearTimeout(timeout);
-      this.flushTimeouts.delete(sessionId);
+    const {
+      snapshot: gitSnapshot,
+      archivePath: createdArchivePath,
+      changed
+    } = captureResult.data;
+    if (!changed || !gitSnapshot) {
+      this.log.debug("No changes since last capture", { lastTreeHash });
+      return { snapshot: null, newTreeHash: lastTreeHash };
     }
-    this.lastFlushAttemptTime.set(sessionId, Date.now());
-    try {
-      await this.posthogAPI.appendTaskRunLog(
-        session.context.taskId,
-        session.context.runId,
-        pending
-      );
-      this.retryCounts.set(sessionId, 0);
-    } catch (error) {
-      const retryCount = (this.retryCounts.get(sessionId) ?? 0) + 1;
-      this.retryCounts.set(sessionId, retryCount);
-      if (retryCount >= _SessionLogWriter.MAX_FLUSH_RETRIES) {
-        this.logger.error(
-          `Dropping ${pending.length} session log entries after ${retryCount} failed flush attempts`,
-          {
-            taskId: session.context.taskId,
-            runId: session.context.runId,
-            error
-          }
+    let archiveUrl;
+    if (apiClient && createdArchivePath) {
+      try {
+        archiveUrl = await this.uploadArchive(
+          createdArchivePath,
+          gitSnapshot.treeHash,
+          apiClient,
+          taskId,
+          runId
         );
-        this.retryCounts.set(sessionId, 0);
-      } else {
-        if (retryCount === 1) {
-          this.logger.warn(
-            `Failed to persist session logs, will retry (up to ${_SessionLogWriter.MAX_FLUSH_RETRIES} attempts)`,
-            {
-              taskId: session.context.taskId,
-              runId: session.context.runId,
-              error: error instanceof Error ? error.message : String(error)
-            }
-          );
-        }
-        const currentPending = this.pendingEntries.get(sessionId) ?? [];
-        this.pendingEntries.set(sessionId, [...pending, ...currentPending]);
-        this.scheduleFlush(sessionId);
+      } finally {
+        await rm7(createdArchivePath, { force: true }).catch(() => {
+        });
       }
     }
+    const snapshot = {
+      treeHash: gitSnapshot.treeHash,
+      baseCommit: gitSnapshot.baseCommit,
+      changes: gitSnapshot.changes,
+      timestamp: gitSnapshot.timestamp,
+      interrupted,
+      archiveUrl
+    };
+    this.log.info("Tree captured", {
+      treeHash: snapshot.treeHash,
+      changes: snapshot.changes.length,
+      interrupted,
+      archiveUrl
+    });
+    return { snapshot, newTreeHash: snapshot.treeHash };
   }
-  getSessionUpdateType(message) {
-    if (message.method !== "session/update") return void 0;
-    const params = message.params;
-    const update = params?.update;
-    return update?.sessionUpdate;
-  }
-  isDirectAgentMessage(message) {
-    return this.getSessionUpdateType(message) === "agent_message";
-  }
-  isAgentMessageChunk(message) {
-    return this.getSessionUpdateType(message) === "agent_message_chunk";
-  }
-  extractChunkText(message) {
-    const params = message.params;
-    const update = params?.update;
-    const content = update?.content;
-    if (content?.type === "text" && content.text) {
-      return content.text;
-    }
-    return "";
-  }
-  emitCoalescedMessage(sessionId, session) {
-    if (!session.chunkBuffer) return;
-    const { text: text2, firstTimestamp } = session.chunkBuffer;
-    session.chunkBuffer = void 0;
-    session.lastAgentMessage = text2;
-    session.currentTurnMessages.push(text2);
-    const entry = {
-      type: "notification",
-      timestamp: firstTimestamp,
-      notification: {
-        jsonrpc: "2.0",
-        method: "session/update",
-        params: {
-          update: {
-            sessionUpdate: "agent_message",
-            content: { type: "text", text: text2 }
+  async uploadArchive(archivePath, treeHash, apiClient, taskId, runId) {
+    const archiveUrl = await this.step({
+      name: "upload_archive",
+      execute: async () => {
+        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`,
+            type: "tree_snapshot",
+            content: base64Content,
+            content_type: "application/gzip"
           }
+        ]);
+        const uploadedArtifact = artifacts[0];
+        if (uploadedArtifact?.storage_path) {
+          this.log.info("Tree archive uploaded", {
+            storagePath: uploadedArtifact.storage_path,
+            treeHash,
+            snapshotBytes,
+            snapshotWireBytes,
+            totalBytes: snapshotBytes,
+            totalWireBytes: snapshotWireBytes
+          });
+          return uploadedArtifact.storage_path;
         }
+        return void 0;
+      },
+      rollback: async () => {
+        await rm7(archivePath, { force: true }).catch(() => {
+        });
       }
-    };
-    this.writeToLocalCache(sessionId, entry);
-    if (this.posthogAPI) {
-      const pending = this.pendingEntries.get(sessionId) ?? [];
-      pending.push(entry);
-      this.pendingEntries.set(sessionId, pending);
-      this.scheduleFlush(sessionId);
-    }
+    });
+    return archiveUrl;
   }
-  getLastAgentMessage(sessionId) {
-    return this.sessions.get(sessionId)?.lastAgentMessage;
+};
+
+// src/tree-tracker.ts
+var TreeTracker = class {
+  repositoryPath;
+  taskId;
+  runId;
+  apiClient;
+  logger;
+  lastTreeHash = null;
+  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: "[TreeTracker]" });
   }
-  getFullAgentResponse(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session || session.currentTurnMessages.length === 0) return void 0;
-    if (session.chunkBuffer) {
-      this.logger.warn(
-        "getFullAgentResponse called with non-empty chunk buffer",
-        {
-          sessionId,
-          bufferedLength: session.chunkBuffer.text.length
-        }
+  /**
+   * Capture current working tree state as a snapshot.
+   * Uses a temporary index to avoid modifying user's staging area.
+   * Uses Saga pattern for atomic operation with automatic cleanup on failure.
+   */
+  async captureTree(options) {
+    const saga = new CaptureTreeSaga2(this.logger);
+    const result = await saga.run({
+      repositoryPath: this.repositoryPath,
+      taskId: this.taskId,
+      runId: this.runId,
+      apiClient: this.apiClient,
+      lastTreeHash: this.lastTreeHash,
+      interrupted: options?.interrupted
+    });
+    if (!result.success) {
+      this.logger.error("Failed to capture tree", {
+        error: result.error,
+        failedStep: result.failedStep
+      });
+      throw new Error(
+        `Failed to capture tree at step '${result.failedStep}': ${result.error}`
       );
     }
-    return session.currentTurnMessages.join("\n\n");
-  }
-  resetTurnMessages(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.currentTurnMessages = [];
+    if (result.data.newTreeHash !== null) {
+      this.lastTreeHash = result.data.newTreeHash;
     }
+    return result.data.snapshot;
   }
-  extractAgentMessageText(message) {
-    if (message.method !== "session/update") {
-      return null;
-    }
-    const params = message.params;
-    const update = params?.update;
-    if (update?.sessionUpdate !== "agent_message") {
-      return null;
-    }
-    const content = update.content;
-    if (content?.type === "text" && typeof content.text === "string") {
-      const trimmed2 = content.text.trim();
-      return trimmed2.length > 0 ? trimmed2 : null;
+  /**
+   * Download and apply a tree snapshot.
+   * Uses Saga pattern for atomic operation with rollback on failure.
+   */
+  async applyTreeSnapshot(snapshot) {
+    if (!this.apiClient) {
+      throw new Error("Cannot apply snapshot: API client not configured");
     }
-    if (typeof update.message === "string") {
-      const trimmed2 = update.message.trim();
-      return trimmed2.length > 0 ? trimmed2 : null;
+    if (!snapshot.archiveUrl) {
+      this.logger.warn("Cannot apply snapshot: no archive URL", {
+        treeHash: snapshot.treeHash,
+        changes: snapshot.changes.length
+      });
+      throw new Error("Cannot apply snapshot: no archive URL");
     }
-    return null;
-  }
-  scheduleFlush(sessionId) {
-    const existing = this.flushTimeouts.get(sessionId);
-    if (existing) clearTimeout(existing);
-    const retryCount = this.retryCounts.get(sessionId) ?? 0;
-    const lastAttempt = this.lastFlushAttemptTime.get(sessionId) ?? 0;
-    const elapsed = Date.now() - lastAttempt;
-    let delay3;
-    if (retryCount > 0) {
-      delay3 = Math.min(
-        _SessionLogWriter.FLUSH_DEBOUNCE_MS * 2 ** retryCount,
-        _SessionLogWriter.MAX_RETRY_DELAY_MS
+    const saga = new ApplySnapshotSaga(this.logger);
+    const result = await saga.run({
+      snapshot,
+      repositoryPath: this.repositoryPath,
+      apiClient: this.apiClient,
+      taskId: this.taskId,
+      runId: this.runId
+    });
+    if (!result.success) {
+      this.logger.error("Failed to apply tree snapshot", {
+        error: result.error,
+        failedStep: result.failedStep,
+        treeHash: snapshot.treeHash
+      });
+      throw new Error(
+        `Failed to apply snapshot at step '${result.failedStep}': ${result.error}`
       );
-    } else if (elapsed >= _SessionLogWriter.FLUSH_MAX_INTERVAL_MS) {
-      delay3 = 0;
-    } else {
-      delay3 = _SessionLogWriter.FLUSH_DEBOUNCE_MS;
     }
-    const timeout = setTimeout(() => this.flush(sessionId), delay3);
-    this.flushTimeouts.set(sessionId, timeout);
+    this.lastTreeHash = result.data.treeHash;
   }
-  writeToLocalCache(sessionId, entry) {
-    if (!this.localCachePath) return;
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    const logPath = path14.join(
-      this.localCachePath,
-      "sessions",
-      session.context.runId,
-      "logs.ndjson"
-    );
-    try {
-      fs12.appendFileSync(logPath, `${JSON.stringify(entry)}
-`);
-    } catch (error) {
-      this.logger.warn("Failed to write to local cache", {
-        taskId: session.context.taskId,
-        runId: session.context.runId,
-        logPath,
-        error
-      });
-    }
+  /**
+   * Get the last captured tree hash.
+   */
+  getLastTreeHash() {
+    return this.lastTreeHash;
   }
-  static async cleanupOldSessions(localCachePath) {
-    const sessionsDir = path14.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);
-        try {
-          const stats = await fsp.stat(entryPath);
-          if (stats.isDirectory() && now - stats.birthtimeMs > _SessionLogWriter.SESSIONS_MAX_AGE_MS) {
-            await fsp.rm(entryPath, { recursive: true, force: true });
-            deleted++;
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-    return deleted;
+  /**
+   * Set the last tree hash (used when resuming).
+   */
+  setLastTreeHash(hash) {
+    this.lastTreeHash = hash;
   }
 };
 
@@ -19968,6 +20816,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 +20875,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 +21206,7 @@ var AgentServer = class {
     return app;
   }
   async start() {
-    await new Promise((resolve6) => {
+    await new Promise((resolve7) => {
       this.server = serve(
         {
           fetch: this.app.fetch,
@@ -20357,51 +21216,35 @@ var AgentServer = class {
           this.logger.debug(
             `HTTP server listening on port ${this.config.port}`
           );
-          resolve6();
+          resolve7();
         }
       );
     });
     await this.autoInitializeSession();
   }
-  async autoInitializeSession() {
-    const { taskId, runId, mode, projectId } = this.config;
-    this.logger.debug("Auto-initializing session", { taskId, runId, mode });
-    const resumeRunId = process.env.POSTHOG_RESUME_RUN_ID;
-    if (resumeRunId) {
-      this.logger.debug("Resuming from previous run", {
-        resumeRunId,
-        currentRunId: runId
+  async loadResumeState(taskId, resumeRunId, currentRunId) {
+    this.logger.debug("Loading resume state", { resumeRunId, currentRunId });
+    try {
+      this.resumeState = await resumeFromLog({
+        taskId,
+        runId: resumeRunId,
+        repositoryPath: this.config.repositoryPath,
+        apiClient: this.posthogAPI,
+        logger: new Logger({ debug: true, prefix: "[Resume]" })
       });
-      try {
-        this.resumeState = await resumeFromLog({
-          taskId,
-          runId: resumeRunId,
-          repositoryPath: this.config.repositoryPath,
-          apiClient: this.posthogAPI,
-          logger: new Logger({ debug: true, prefix: "[Resume]" })
-        });
-        this.logger.debug("Resume state loaded", {
-          conversationTurns: this.resumeState.conversation.length,
-          snapshotApplied: this.resumeState.snapshotApplied,
-          logEntries: this.resumeState.logEntryCount
-        });
-      } catch (error) {
-        this.logger.debug("Failed to load resume state, starting fresh", {
-          error
-        });
-        this.resumeState = null;
-      }
+      this.logger.debug("Resume state loaded", {
+        conversationTurns: this.resumeState.conversation.length,
+        hasSnapshot: !!this.resumeState.latestSnapshot,
+        hasGitCheckpoint: !!this.resumeState.latestGitCheckpoint,
+        gitCheckpointBranch: this.resumeState.latestGitCheckpoint?.branch ?? null,
+        logEntries: this.resumeState.logEntryCount
+      });
+    } catch (error) {
+      this.logger.debug("Failed to load resume state, starting fresh", {
+        error
+      });
+      this.resumeState = null;
     }
-    const payload = {
-      task_id: taskId,
-      run_id: runId,
-      team_id: projectId,
-      user_id: 0,
-      // System-initiated
-      distinct_id: "agent-server",
-      mode
-    };
-    await this.initializeSession(payload, null);
   }
   async stop() {
     this.logger.debug("Stopping agent server...");
@@ -20511,6 +21354,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 +21584,8 @@ var AgentServer = class {
       deviceInfo,
       logWriter,
       permissionMode: initialPermissionMode,
-      hasDesktopConnected: sseController !== null
+      hasDesktopConnected: sseController !== null,
+      pendingHandoffGitState: void 0
     };
     this.logger = new Logger({
       debug: true,
@@ -20795,29 +21643,11 @@ var AgentServer = class {
     if (!this.resumeState) {
       const resumeRunId = this.getResumeRunId(taskRun);
       if (resumeRunId) {
-        this.logger.debug("Resuming from previous run (via TaskRun state)", {
+        await this.loadResumeState(
+          payload.task_id,
           resumeRunId,
-          currentRunId: payload.run_id
-        });
-        try {
-          this.resumeState = await resumeFromLog({
-            taskId: payload.task_id,
-            runId: resumeRunId,
-            repositoryPath: this.config.repositoryPath,
-            apiClient: this.posthogAPI,
-            logger: new Logger({ debug: true, prefix: "[Resume]" })
-          });
-          this.logger.debug("Resume state loaded (via TaskRun state)", {
-            conversationTurns: this.resumeState.conversation.length,
-            snapshotApplied: this.resumeState.snapshotApplied,
-            logEntries: this.resumeState.logEntryCount
-          });
-        } catch (error) {
-          this.logger.debug("Failed to load resume state, starting fresh", {
-            error
-          });
-          this.resumeState = null;
-        }
+          payload.run_id
+        );
       }
     }
     if (this.resumeState && this.resumeState.conversation.length > 0) {
@@ -20876,8 +21706,59 @@ var AgentServer = class {
       const conversationSummary = formatConversationForResume(
         this.resumeState.conversation
       );
+      let snapshotApplied = false;
+      if (this.resumeState.latestSnapshot?.archiveUrl && this.config.repositoryPath && this.posthogAPI) {
+        try {
+          const treeTracker = new TreeTracker({
+            repositoryPath: this.config.repositoryPath,
+            taskId: payload.task_id,
+            runId: payload.run_id,
+            apiClient: this.posthogAPI,
+            logger: this.logger.child("TreeTracker")
+          });
+          await treeTracker.applyTreeSnapshot(this.resumeState.latestSnapshot);
+          treeTracker.setLastTreeHash(this.resumeState.latestSnapshot.treeHash);
+          snapshotApplied = true;
+          this.logger.info("Tree snapshot applied", {
+            treeHash: this.resumeState.latestSnapshot.treeHash,
+            changes: this.resumeState.latestSnapshot.changes?.length ?? 0,
+            hasArchiveUrl: !!this.resumeState.latestSnapshot.archiveUrl
+          });
+        } catch (error) {
+          this.logger.warn("Failed to apply tree snapshot", {
+            error: error instanceof Error ? error.message : String(error),
+            treeHash: this.resumeState.latestSnapshot.treeHash
+          });
+        }
+      }
+      if (this.resumeState.latestGitCheckpoint && this.config.repositoryPath && this.posthogAPI) {
+        try {
+          const checkpointTracker = new HandoffCheckpointTracker({
+            repositoryPath: this.config.repositoryPath,
+            taskId: payload.task_id,
+            runId: payload.run_id,
+            apiClient: this.posthogAPI,
+            logger: this.logger.child("HandoffCheckpoint")
+          });
+          const metrics = await checkpointTracker.applyFromHandoff(
+            this.resumeState.latestGitCheckpoint
+          );
+          this.logger.info("Git checkpoint applied", {
+            branch: this.resumeState.latestGitCheckpoint.branch,
+            head: this.resumeState.latestGitCheckpoint.head,
+            packBytes: metrics.packBytes,
+            indexBytes: metrics.indexBytes,
+            totalBytes: metrics.totalBytes
+          });
+        } catch (error) {
+          this.logger.warn("Failed to apply git checkpoint", {
+            error: error instanceof Error ? error.message : String(error),
+            branch: this.resumeState.latestGitCheckpoint.branch
+          });
+        }
+      }
       const pendingUserPrompt = await this.getPendingUserPrompt(taskRun);
-      const sandboxContext = this.resumeState.snapshotApplied ? `The workspace environment (all files, packages, and code changes) has been fully restored from where you left off.` : `The workspace files from the previous session were not restored (the file snapshot may have expired), so you are starting with a fresh environment. Your conversation history is fully preserved below.`;
+      const sandboxContext = snapshotApplied ? `The workspace environment (all files, packages, and code changes) has been fully restored from where you left off.` : `The workspace files from the previous session were not restored (the file snapshot may have expired), so you are starting with a fresh environment. Your conversation history is fully preserved below.`;
       let resumePromptBlocks;
       if (pendingUserPrompt?.length) {
         resumePromptBlocks = [
@@ -20918,7 +21799,9 @@ Continue from where you left off. The user is waiting for your response.`
         conversationTurns: this.resumeState.conversation.length,
         promptLength: promptBlocksToText(resumePromptBlocks).length,
         hasPendingUserMessage: !!pendingUserPrompt?.length,
-        snapshotApplied: this.resumeState.snapshotApplied
+        snapshotApplied,
+        hasGitCheckpoint: !!this.resumeState.latestGitCheckpoint,
+        gitCheckpointBranch: this.resumeState.latestGitCheckpoint?.branch ?? null
       });
       this.resumeState = null;
       this.session.logWriter.resetTurnMessages(payload.run_id);
@@ -21062,16 +21945,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 } : {}
@@ -21082,6 +21965,24 @@ Continue from where you left off. The user is waiting for your response.`
     const normalizedName = baseName.replace(/[^\w.-]/g, "_");
     return normalizedName.length > 0 ? normalizedName : "attachment";
   }
+  async autoInitializeSession() {
+    const { taskId, runId, mode, projectId } = this.config;
+    this.logger.debug("Auto-initializing session", { taskId, runId, mode });
+    const resumeRunId = process.env.POSTHOG_RESUME_RUN_ID;
+    if (resumeRunId) {
+      await this.loadResumeState(taskId, resumeRunId, runId);
+    }
+    const payload = {
+      task_id: taskId,
+      run_id: runId,
+      team_id: projectId,
+      user_id: 0,
+      // System-initiated
+      distinct_id: "agent-server",
+      mode
+    };
+    await this.initializeSession(payload, null);
+  }
   getResumeRunId(taskRun) {
     const envRunId = process.env.POSTHOG_RESUME_RUN_ID;
     if (envRunId) return envRunId;
@@ -21570,6 +22471,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 +22535,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 +22632,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) {