@posthog/agent 2.3.401 → 2.3.403

package/dist/server/agent-server.js

@@ -809,10 +809,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log = debug_1.default("@kwsites/file-exists");
-    function check(path17, isFile2, isDirectory) {
-      log(`checking %s`, path17);
+    function check(path16, isFile2, isDirectory) {
+      log(`checking %s`, path16);
       try {
-        const stat4 = fs_1.statSync(path17);
+        const stat4 = fs_1.statSync(path16);
         if (stat4.isFile() && isFile2) {
           log(`[OK] path represents a file`);
           return true;
@@ -832,8 +832,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path17, type = exports2.READABLE) {
-      return check(path17, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
+    function exists2(path16, type = exports2.READABLE) {
+      return check(path16, (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(path17) {
+            function locateFile(path16) {
               if (Module["locateFile"]) {
-                return Module["locateFile"](path17, scriptDirectory);
+                return Module["locateFile"](path16, scriptDirectory);
               }
-              return scriptDirectory + path17;
+              return scriptDirectory + path16;
             }
             var readAsync, readBinary;
             if (ENVIRONMENT_IS_NODE) {
@@ -3454,8 +3454,8 @@ var require_tree_sitter = __commonJS({
                 } else {
                   const url = input;
                   if (typeof process !== "undefined" && process.versions && process.versions.node) {
-                    const fs14 = __require("fs");
-                    bytes = Promise.resolve(fs14.readFileSync(url));
+                    const fs13 = __require("fs");
+                    bytes = Promise.resolve(fs13.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 mkdir8, writeFile as writeFile6 } from "fs/promises";
-import { basename as basename2, join as join14 } from "path";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { basename as basename2, join as join11 } 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(path17) {
-  return path17 instanceof String && cache.has(path17);
+function isPathSpec(path16) {
+  return path16 instanceof String && cache.has(path16);
 }
 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(path17) {
-  return (0, import_file_exists.exists)(path17, import_file_exists.FOLDER);
+function folderExists(path16) {
+  return (0, import_file_exists.exists)(path16, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -4330,8 +4330,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path17) {
-      return /^\.(git)?$/.test(path17.trim());
+    parser(path16) {
+      return /^\.(git)?$/.test(path16.trim());
     }
   };
 }
@@ -4765,11 +4765,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path17, line, preview] = input.split(NULL);
-    paths.add(path17);
-    (results[path17] = results[path17] || []).push({
+    const [path16, line, preview] = input.split(NULL);
+    paths.add(path16);
+    (results[path16] = results[path16] || []).push({
       line: asNumber(line),
-      path: path17,
+      path: path16,
       preview
     });
   });
@@ -5534,14 +5534,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path17, text2) {
+function parseInit(bare, path16, text2) {
   const response = String(text2).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path17, false, result[1]);
+    return new InitSummary(bare, path16, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path17, true, result[1]);
+    return new InitSummary(bare, path16, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -5552,7 +5552,7 @@ function parseInit(bare, path17, text2) {
       break;
     }
   }
-  return new InitSummary(bare, path17, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path16, /^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, path17, existing, gitDir) {
+      constructor(bare, path16, existing, gitDir) {
         this.bare = bare;
-        this.path = path17;
+        this.path = path16;
         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, path17, customArgs) {
+function initTask(bare = false, path16, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -5584,7 +5584,7 @@ function initTask(bare = false, path17, customArgs) {
     commands,
     format: "utf-8",
     parser(text2) {
-      return parseInit(commands.includes("--bare"), path17, text2);
+      return parseInit(commands.includes("--bare"), path16, text2);
     }
   };
 }
@@ -6400,12 +6400,12 @@ var init_FileStatusSummary = __esm({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path17, index, working_dir) {
-        this.path = path17;
+      constructor(path16, index, working_dir) {
+        this.path = path16;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path17) || [null, path17, path17];
+          const detail = fromPathRegex.exec(path16) || [null, path16, path16];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -6436,14 +6436,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path17) {
+  function data(index, workingDir, path16) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path17);
+      handler(result, path16);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path17, index, workingDir));
+      result.files.push(new FileStatusSummary(path16, index, workingDir));
     }
   }
 }
@@ -6756,9 +6756,9 @@ var init_simple_git_api = __esm({
           next
         );
       }
-      hashObject(path17, write) {
+      hashObject(path16, write) {
         return this._runTask(
-          hashObjectTask(path17, write === true),
+          hashObjectTask(path16, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -7111,8 +7111,8 @@ var init_branch = __esm({
   }
 });
 function toPath(input) {
-  const path17 = input.trim().replace(/^["']|["']$/g, "");
-  return path17 && normalize(path17);
+  const path16 = input.trim().replace(/^["']|["']$/g, "");
+  return path16 && normalize(path16);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
@@ -7426,8 +7426,8 @@ __export(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path17) {
-  return subModuleTask(["add", repo, path17]);
+function addSubModuleTask(repo, path16) {
+  return subModuleTask(["add", repo, path16]);
 }
 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, path17, then) {
-      return this._runTask(addSubModuleTask2(repo, path17), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path16, then) {
+      return this._runTask(addSubModuleTask2(repo, path16), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args2, then) {
       return this._runTask(
@@ -8591,12 +8591,6 @@ async function listWorktrees(baseDir, options) {
     return worktrees;
   }, { signal: options?.abortSignal });
 }
-async function getHeadSha(baseDir, options) {
-  const manager = getGitOperationManager();
-  return manager.executeRead(baseDir, (git) => git.revparse(["HEAD"]), {
-    signal: options?.abortSignal
-  });
-}
 
 // src/server/agent-server.ts
 import { Hono } from "hono";
@@ -8605,7 +8599,7 @@ import { z as z4 } from "zod";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.401",
+  version: "2.3.403",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -8673,10 +8667,6 @@ var package_default = {
       types: "./dist/handoff-checkpoint.d.ts",
       import: "./dist/handoff-checkpoint.js"
     },
-    "./tree-tracker": {
-      types: "./dist/tree-tracker.d.ts",
-      import: "./dist/tree-tracker.js"
-    },
     "./server": {
       types: "./dist/server/agent-server.d.ts",
       import: "./dist/server/agent-server.js"
@@ -8772,8 +8762,6 @@ var POSTHOG_NOTIFICATIONS = {
   CONSOLE: "_posthog/console",
   /** Maps taskRunId to agent's sessionId and adapter type (for resumption) */
   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) */
@@ -8812,9 +8800,6 @@ function matchesExt(method, expected) {
   if (!method) return false;
   return method === expected || method === `_${expected}`;
 }
-function isNotification(method, expected) {
-  return matchesExt(method, expected);
-}
 function isMethod(method, expected) {
   return matchesExt(method, expected);
 }
@@ -13450,8 +13435,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path17, oldText, newText) {
-    this.items.push({ type: "diff", path: path17, oldText, newText });
+  diff(path16, oldText, newText) {
+    this.items.push({ type: "diff", path: path16, oldText, newText });
     return this;
   }
   build() {
@@ -18444,19 +18429,14 @@ function createCodexConnection(config) {
 }
 
 // src/handoff-checkpoint.ts
-import {
-  mkdir as mkdir4,
-  readdir,
-  readFile as readFile4,
-  rm as rm4,
-  rmdir,
-  writeFile as writeFile2
-} from "fs/promises";
-import { join as join9 } from "path";
+import { mkdtemp as mkdtemp2, readFile as readFile4, rm as rm4, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname as dirname6, join as join9 } from "path";
 
 // ../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 { copyFile, mkdtemp, readFile as readFile3, rm as rm3, stat as stat3 } from "fs/promises";
+import { tmpdir } from "os";
 import path13 from "path";
 
 // ../git/dist/sagas/checkpoint.js
@@ -18864,7 +18844,7 @@ var GitHandoffTracker = class {
     this.repositoryPath = config.repositoryPath;
     this.logger = config.logger;
   }
-  async captureForHandoff(localGitState) {
+  async captureForHandoff(_localGitState) {
     const captureSaga = new CaptureCheckpointSaga(this.logger);
     const result = await captureSaga.run({ baseDir: this.repositoryPath });
     if (!result.success) {
@@ -18872,15 +18852,19 @@ var GitHandoffTracker = class {
     }
     const checkpoint = result.data;
     const git = createGitClient(this.repositoryPath);
-    const tempDir = await this.getTempDir(git);
+    const tempDir = await this.createTempDir(checkpoint.checkpointId);
     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 packRefs = [
+      checkpoint.head,
+      checkpoint.indexTree,
+      checkpoint.worktreeTree
+    ].filter((ref) => !!ref);
+    const headRef = checkpoint.head ? `${HANDOFF_HEAD_REF_PREFIX}${checkpoint.checkpointId}` : void 0;
     const packPrefix = path13.join(tempDir, checkpoint.checkpointId);
     try {
       const [headPack, indexFile, tracking] = await Promise.all([
-        shouldIncludeHead && checkpoint.head ? this.captureHeadPack(packPrefix, checkpoint.head) : Promise.resolve(void 0),
-        this.copyIndexFile(git, checkpoint.checkpointId),
+        this.captureObjectPack(packPrefix, packRefs),
+        this.copyIndexFile(git, checkpoint.checkpointId, tempDir),
         getTrackingMetadata(git, checkpoint.branch)
       ]);
       return {
@@ -18927,6 +18911,8 @@ var GitHandoffTracker = class {
     } else if (checkpoint.head) {
       await git.checkout(checkpoint.head);
     }
+    await git.clean(["f", "d"]);
+    await git.raw(["read-tree", "--reset", "-u", checkpoint.worktreeTree]);
     if (indexPath) {
       await this.restoreIndexFile(git, indexPath);
     }
@@ -18938,8 +18924,8 @@ var GitHandoffTracker = class {
       totalBytes: packBytes + indexBytes
     };
   }
-  async captureHeadPack(packPrefix, headCommit) {
-    const hash = await this.runGitWithInput(["pack-objects", packPrefix, "--revs"], `${headCommit}
+  async captureObjectPack(packPrefix, refs) {
+    const hash = await this.runGitWithInput(["pack-objects", packPrefix, "--revs"], `${refs.join("\n")}
 `);
     const packPath = `${packPrefix}-${hash.trim()}.pack`;
     const rawBytes = await this.getFileSize(packPath);
@@ -18947,9 +18933,8 @@ var GitHandoffTracker = class {
     });
     return { path: packPath, rawBytes };
   }
-  async copyIndexFile(git, checkpointId) {
+  async copyIndexFile(git, checkpointId, tempDir) {
     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 {
@@ -19077,13 +19062,8 @@ var GitHandoffTracker = class {
     ]);
     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 createTempDir(checkpointId) {
+    return mkdtemp(joinTempPrefix(checkpointId));
   }
   async getGitPath(git, gitPath) {
     const raw = await git.raw(["rev-parse", "--git-path", gitPath]);
@@ -19150,6 +19130,9 @@ var GitHandoffTracker = class {
     });
   }
 };
+function joinTempPrefix(checkpointId) {
+  return path13.join(tmpdir(), `posthog-code-handoff-${checkpointId}-`);
+}
 async function getCurrentBranchName(git) {
   try {
     const raw = await git.revparse(["--abbrev-ref", "HEAD"]);
@@ -19236,8 +19219,11 @@ var HandoffCheckpointTracker = class {
         indexArtifactPath: uploads.index?.storagePath
       };
     } finally {
+      const tempDir = capture.headPack?.path ? dirname6(capture.headPack.path) : dirname6(capture.indexFile.path);
       await this.removeIfPresent(capture.headPack?.path);
       await this.removeIfPresent(capture.indexFile.path);
+      await rm4(tempDir, { recursive: true, force: true }).catch(() => {
+      });
     }
   }
   async applyFromHandoff(checkpoint, options) {
@@ -19247,8 +19233,9 @@ var HandoffCheckpointTracker = class {
       );
     }
     const gitTracker = this.createGitTracker();
-    const tmpDir = join9(this.repositoryPath, ".posthog", "tmp");
-    await mkdir4(tmpDir, { recursive: true });
+    const tmpDir = await mkdtemp2(
+      join9(tmpdir2(), `posthog-code-handoff-${checkpoint.checkpointId}-`)
+    );
     const packPath = join9(tmpDir, `${checkpoint.checkpointId}.pack`);
     const indexPath = join9(tmpDir, `${checkpoint.checkpointId}.index`);
     try {
@@ -19282,7 +19269,8 @@ var HandoffCheckpointTracker = class {
     } finally {
       await this.removeIfPresent(packPath);
       await this.removeIfPresent(indexPath);
-      await this.removeTmpDirIfEmpty(tmpDir);
+      await rm4(tmpDir, { recursive: true, force: true }).catch(() => {
+      });
     }
   }
   toGitCheckpoint(checkpoint) {
@@ -19390,50 +19378,24 @@ var HandoffCheckpointTracker = class {
   }
   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)
+      head: checkpoint.head?.slice(0, 7),
+      totalBytes: this.sumRawBytes(uploads.pack, uploads.index)
     });
   }
-  logApplyMetrics(checkpoint, downloads, totalBytes) {
+  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)
+      head: checkpoint.head?.slice(0, 7),
+      totalBytes
     });
   }
-  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;
@@ -19441,14 +19403,6 @@ var HandoffCheckpointTracker = class {
     await rm4(filePath, { force: true }).catch(() => {
     });
   }
-  async removeTmpDirIfEmpty(tmpDir) {
-    const entries = await readdir(tmpDir).catch(() => null);
-    if (!entries || entries.length > 0) {
-      return;
-    }
-    await rmdir(tmpDir).catch(() => {
-    });
-  }
 };
 
 // src/utils/gateway.ts
@@ -19721,21 +19675,10 @@ var ResumeSaga = class extends Saga {
       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,
@@ -19752,15 +19695,13 @@ var ResumeSaga = class extends Saga {
     );
     this.log.info("Resume state rebuilt", {
       turns: conversation.length,
-      hasSnapshot: !!latestSnapshot,
       hasGitCheckpoint: !!latestGitCheckpoint,
-      interrupted: latestSnapshot?.interrupted ?? false
+      interrupted: false
     });
     return {
       conversation,
-      latestSnapshot,
       latestGitCheckpoint,
-      interrupted: latestSnapshot?.interrupted ?? false,
+      interrupted: false,
       lastDevice,
       logEntryCount: entries.length
     };
@@ -19768,27 +19709,11 @@ var ResumeSaga = class extends Saga {
   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--) {
@@ -19950,7 +19875,6 @@ async function resumeFromLog(config) {
   }
   return {
     conversation: result.data.conversation,
-    latestSnapshot: result.data.latestSnapshot,
     latestGitCheckpoint: result.data.latestGitCheckpoint,
     interrupted: result.data.interrupted,
     lastDevice: result.data.lastDevice,
@@ -20338,575 +20262,6 @@ var SessionLogWriter = class _SessionLogWriter {
   }
 };
 
-// src/sagas/apply-snapshot-saga.ts
-import { mkdir as mkdir7, readdir as readdir2, rm as rm6, rmdir as rmdir2, 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);
-    }
-    this.log.info("Tree captured", {
-      treeHash,
-      changes: changes.length,
-      archived: !!createdArchivePath
-    });
-    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;
-    }
-    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(() => {
-        });
-      }
-    });
-    return archivePath;
-  }
-  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" }));
-    }
-    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 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;
-      }
-      try {
-        branch = await this.git.raw(["symbolic-ref", "--short", "HEAD"]);
-      } catch {
-        branch = null;
-      }
-      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 };
-  }
-};
-
-// 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 archiveUrl = snapshot.archiveUrl;
-    try {
-      await this.step({
-        name: "create_tmp_dir",
-        execute: () => mkdir7(tmpDir, { recursive: true }),
-        rollback: async () => {
-        }
-      });
-      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}`);
-      }
-      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 };
-    } finally {
-      if (this.archivePath) {
-        await rm6(this.archivePath, { force: true }).catch(() => {
-        });
-      }
-      await this.removeTmpDirIfEmpty(tmpDir);
-      this.archivePath = null;
-    }
-  }
-  async removeTmpDirIfEmpty(tmpDir) {
-    const entries = await readdir2(tmpDir).catch(() => null);
-    if (!entries || entries.length > 0) {
-      return;
-    }
-    await rmdir2(tmpDir).catch(() => {
-    });
-  }
-};
-
-// src/sagas/capture-tree-saga.ts
-import { existsSync as existsSync6 } from "fs";
-import { readdir as readdir3, readFile as readFile6, rm as rm7, rmdir as rmdir3 } 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 shouldArchive = !!apiClient;
-    const archivePath = shouldArchive ? join13(tmpDir, `tree-${Date.now()}.tar.gz`) : void 0;
-    try {
-      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 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 };
-    } finally {
-      if (archivePath) {
-        await rm7(archivePath, { force: true }).catch(() => {
-        });
-      }
-      await this.removeTmpDirIfEmpty(tmpDir);
-    }
-  }
-  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(() => {
-        });
-      }
-    });
-    return archiveUrl;
-  }
-  async removeTmpDirIfEmpty(tmpDir) {
-    const entries = await readdir3(tmpDir).catch(() => null);
-    if (!entries || entries.length > 0) {
-      return;
-    }
-    await rmdir3(tmpDir).catch(() => {
-    });
-  }
-};
-
-// 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]" });
-  }
-  /**
-   * 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}`
-      );
-    }
-    if (result.data.newTreeHash !== null) {
-      this.lastTreeHash = result.data.newTreeHash;
-    }
-    return result.data.snapshot;
-  }
-  /**
-   * 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 (!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}`
-      );
-    }
-    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/server/cloud-prompt.ts
 function normalizeCloudPromptContent(content) {
   if (typeof content === "string") {
@@ -21391,7 +20746,6 @@ var AgentServer = class {
       });
       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
@@ -21637,13 +20991,6 @@ var AgentServer = class {
       getApiKey: () => this.config.apiKey,
       userAgent: `posthog/cloud.hog.dev; version: ${this.config.version ?? package_default.version}`
     });
-    const treeTracker = this.config.repositoryPath ? new TreeTracker({
-      repositoryPath: this.config.repositoryPath,
-      taskId: payload.task_id,
-      runId: payload.run_id,
-      apiClient: posthogAPI,
-      logger: new Logger({ debug: true, prefix: "[TreeTracker]" })
-    }) : null;
     const logWriter = new SessionLogWriter({
       posthogAPI,
       logger: new Logger({ debug: true, prefix: "[SessionLogWriter]" })
@@ -21736,7 +21083,6 @@ var AgentServer = class {
       acpSessionId,
       acpConnection,
       clientConnection,
-      treeTracker,
       sseController,
       deviceInfo,
       logWriter,
@@ -21863,31 +21209,7 @@ 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
-          });
-        }
-      }
+      let checkpointApplied = false;
       if (this.resumeState.latestGitCheckpoint && this.config.repositoryPath && this.posthogAPI) {
         try {
           const checkpointTracker = new HandoffCheckpointTracker({
@@ -21900,6 +21222,7 @@ var AgentServer = class {
           const metrics = await checkpointTracker.applyFromHandoff(
             this.resumeState.latestGitCheckpoint
           );
+          checkpointApplied = true;
           this.logger.info("Git checkpoint applied", {
             branch: this.resumeState.latestGitCheckpoint.branch,
             head: this.resumeState.latestGitCheckpoint.head,
@@ -21915,7 +21238,7 @@ var AgentServer = class {
         }
       }
       const pendingUserPrompt = await this.getPendingUserPrompt(taskRun);
-      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.`;
+      const sandboxContext = checkpointApplied ? `The workspace environment (all files, packages, and code changes) has been fully restored from the latest checkpoint.` : `The workspace from the previous session was not restored from a checkpoint, so you are starting with a fresh environment. Your conversation history is fully preserved below.`;
       let resumePromptBlocks;
       if (pendingUserPrompt?.length) {
         resumePromptBlocks = [
@@ -21956,7 +21279,7 @@ 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,
+        checkpointApplied,
         hasGitCheckpoint: !!this.resumeState.latestGitCheckpoint,
         gitCheckpointBranch: this.resumeState.latestGitCheckpoint?.branch ?? null
       });
@@ -22102,16 +21425,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 = join14(
+    const artifactDir = join11(
       this.config.repositoryPath ?? "/tmp/workspace",
       ".posthog",
       "attachments",
       runId,
       artifact.id ?? safeName
     );
-    await mkdir8(artifactDir, { recursive: true });
-    const artifactPath = join14(artifactDir, safeName);
-    await writeFile6(artifactPath, Buffer.from(data));
+    await mkdir4(artifactDir, { recursive: true });
+    const artifactPath = join11(artifactDir, safeName);
+    await writeFile4(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 } : {}
@@ -22466,8 +21789,8 @@ ${attributionInstructions}
           const meta = params.update?._meta?.claudeCode;
           const toolName = meta?.toolName;
           const toolResponse = meta?.toolResponse;
-          if ((toolName === "Write" || toolName === "Edit") && toolResponse?.filePath) {
-            await this.captureTreeState();
+          if ((toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit" || toolName === "Delete" || toolName === "Move") && toolResponse?.filePath) {
+            await this.captureCheckpointState();
           }
           if (toolName && (toolName.includes("Bash") || toolName.includes("bash"))) {
             this.detectAndAttachPrUrl(payload, params.update);
@@ -22629,14 +21952,9 @@ ${attributionInstructions}
     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();
+      await this.captureCheckpointState(this.session.pendingHandoffGitState);
     } catch (error) {
-      this.logger.error("Failed to capture final tree state", error);
+      this.logger.error("Failed to capture final checkpoint state", error);
     }
     try {
       await this.session.logWriter.flush(this.session.payload.run_id, {
@@ -22664,41 +21982,13 @@ ${attributionInstructions}
     this.lastReportedBranch = null;
     this.session = null;
   }
-  async captureTreeState() {
-    if (!this.session?.treeTracker) return;
-    try {
-      const snapshot = await this.session.treeTracker.captureTree({});
-      if (snapshot) {
-        const snapshotWithDevice = {
-          ...snapshot,
-          device: this.session.deviceInfo
-        };
-        const notification = {
-          jsonrpc: "2.0",
-          method: POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT,
-          params: snapshotWithDevice
-        };
-        this.broadcastEvent({
-          type: "notification",
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          notification
-        });
-        this.session.logWriter.appendRawLine(
-          this.session.payload.run_id,
-          JSON.stringify(notification)
-        );
-      }
-    } catch (error) {
-      this.logger.error("Failed to capture tree state", error);
-    }
-  }
-  async captureHandoffCheckpoint() {
-    if (!this.session?.treeTracker || !this.session.pendingHandoffGitState) {
+  async captureCheckpointState(localGitState) {
+    if (!this.session || !this.config.repositoryPath) {
       return;
     }
     if (!this.posthogAPI) {
       this.logger.warn(
-        "Skipping handoff checkpoint capture: PostHog API client is not configured"
+        "Skipping checkpoint capture: PostHog API client is not configured"
       );
       return;
     }
@@ -22709,9 +21999,7 @@ ${attributionInstructions}
       apiClient: this.posthogAPI,
       logger: this.logger.child("HandoffCheckpoint")
     });
-    const checkpoint = await tracker.captureForHandoff(
-      this.session.pendingHandoffGitState
-    );
+    const checkpoint = await tracker.captureForHandoff(localGitState);
     if (!checkpoint) return;
     const checkpointWithDevice = {
       ...checkpoint,