@posthog/agent 2.3.387 → 2.3.398

package/dist/server/agent-server.js

@@ -8605,7 +8605,7 @@ import { z as z4 } from "zod";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.387",
+  version: "2.3.398",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -8657,6 +8657,10 @@ var package_default = {
       types: "./dist/adapters/reasoning-effort.d.ts",
       import: "./dist/adapters/reasoning-effort.js"
     },
+    "./adapters/claude/mcp/tool-metadata": {
+      types: "./dist/adapters/claude/mcp/tool-metadata.d.ts",
+      import: "./dist/adapters/claude/mcp/tool-metadata.js"
+    },
     "./execution-mode": {
       types: "./dist/execution-mode.d.ts",
       import: "./dist/execution-mode.js"
@@ -13657,10 +13661,12 @@ async function fetchMcpToolMetadata(q, logger = new Logger({ debug: false, prefi
       for (const tool of server.tools) {
         const toolKey = buildToolKey(server.name, tool.name);
         const readOnly = tool.annotations?.readOnly === true;
+        const existing = mcpToolMetadataCache.get(toolKey);
         mcpToolMetadataCache.set(toolKey, {
           readOnly,
           name: tool.name,
-          description: tool.description
+          description: tool.description,
+          approvalState: existing?.approvalState
         });
         if (readOnly) readOnlyCount++;
       }
@@ -13702,6 +13708,23 @@ function getConnectedMcpServerNames() {
   }
   return [...names];
 }
+function getMcpToolApprovalState(toolName) {
+  return mcpToolMetadataCache.get(toolName)?.approvalState;
+}
+function setMcpToolApprovalStates(approvals) {
+  for (const [toolKey, approvalState] of Object.entries(approvals)) {
+    const existing = mcpToolMetadataCache.get(toolKey);
+    if (existing) {
+      existing.approvalState = approvalState;
+    } else {
+      mcpToolMetadataCache.set(toolKey, {
+        readOnly: false,
+        name: toolKey,
+        approvalState
+      });
+    }
+  }
+}
 
 // src/adapters/claude/conversion/tool-use-to-acp.ts
 var SYSTEM_REMINDER_REGEX = /\s*<system-reminder>[\s\S]*?<\/system-reminder>/g;
@@ -15397,6 +15420,72 @@ async function handleDefaultPermissionFlow(context) {
     return { behavior: "deny", message, interrupt: !feedback };
   }
 }
+function parseMcpToolName(toolName) {
+  const parts2 = toolName.split("__");
+  return {
+    serverName: parts2[1] ?? toolName,
+    tool: parts2.slice(2).join("__") || toolName
+  };
+}
+async function handleMcpApprovalFlow(context) {
+  const { toolName, toolInput, toolUseID, client, sessionId } = context;
+  const { serverName, tool: displayTool } = parseMcpToolName(toolName);
+  const metadata2 = getMcpToolMetadata(toolName);
+  const description = metadata2?.description ? `
+
+${metadata2.description}` : "";
+  const response = await client.requestPermission({
+    options: [
+      { kind: "allow_once", name: "Yes", optionId: "allow" },
+      {
+        kind: "allow_always",
+        name: "Yes, always allow",
+        optionId: "allow_always"
+      },
+      {
+        kind: "reject_once",
+        name: "Type here to tell the agent what to do differently",
+        optionId: "reject",
+        _meta: { customInput: true }
+      }
+    ],
+    sessionId,
+    toolCall: {
+      toolCallId: toolUseID,
+      title: `The agent wants to call ${displayTool} (${serverName})`,
+      kind: "other",
+      content: description ? [{ type: "content", content: text(description) }] : [],
+      rawInput: { ...toolInput, toolName }
+    }
+  });
+  if (context.signal?.aborted || response.outcome?.outcome === "cancelled") {
+    throw new Error("Tool use aborted");
+  }
+  if (response.outcome?.outcome === "selected" && (response.outcome.optionId === "allow" || response.outcome.optionId === "allow_always")) {
+    if (response.outcome.optionId === "allow_always") {
+      return {
+        behavior: "allow",
+        updatedInput: toolInput,
+        updatedPermissions: [
+          {
+            type: "addRules",
+            rules: [{ toolName }],
+            behavior: "allow",
+            destination: "localSettings"
+          }
+        ]
+      };
+    }
+    return {
+      behavior: "allow",
+      updatedInput: toolInput
+    };
+  }
+  const feedback = response._meta?.customInput?.trim();
+  const message = feedback ? `User refused permission to run tool with feedback: ${feedback}` : "User refused permission to run tool";
+  await emitToolDenial(context, message);
+  return { behavior: "deny", message, interrupt: !feedback };
+}
 function handlePlanFileException(context) {
   const { session, toolName, toolInput } = context;
   if (session.permissionMode !== "plan" || !WRITE_TOOLS.has(toolName)) {
@@ -15467,6 +15556,17 @@ async function canUseTool(context) {
       }
     }
   }
+  if (toolName.startsWith("mcp__")) {
+    const approvalState = getMcpToolApprovalState(toolName);
+    if (approvalState === "do_not_use") {
+      const message = "This tool has been blocked. To re-enable it, go to Settings > MCP Servers in PostHog Code.";
+      await emitToolDenial(context, message);
+      return { behavior: "deny", message, interrupt: false };
+    }
+    if (approvalState === "needs_approval") {
+      return handleMcpApprovalFlow(context);
+    }
+  }
   if (isToolAllowedForMode(toolName, session.permissionMode)) {
     return {
       behavior: "allow",
@@ -15679,7 +15779,14 @@ Only enter plan mode (EnterPlanMode) when the user is requesting a significant c
 
 When in doubt, continue executing and incorporate the feedback inline.
 `;
-var APPENDED_INSTRUCTIONS = BRANCH_NAMING + PLAN_MODE;
+var MCP_TOOLS = `
+# MCP Tool Access
+
+If an MCP tool call is explicitly denied with a message, relay that denial message to the user exactly as given. Do NOT suggest checking "Claude Code settings."
+
+If an MCP tool call returns an error, treat it as a normal tool error \u2014 troubleshoot, retry, or inform the user about the specific error. Do NOT assume it is a permissions issue and do NOT direct the user to any settings page.
+`;
+var APPENDED_INSTRUCTIONS = BRANCH_NAMING + PLAN_MODE + MCP_TOOLS;
 
 // src/adapters/claude/session/options.ts
 function buildSystemPrompt(customPrompt) {
@@ -17008,6 +17115,9 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     const earlyModelId = settingsManager.getSettings().model || meta?.model || "";
     const mcpServers = supportsMcpInjection(earlyModelId) ? parseMcpServers(params) : {};
     const systemPrompt = buildSystemPrompt(meta?.systemPrompt);
+    if (meta?.mcpToolApprovals) {
+      setMcpToolApprovalStates(meta.mcpToolApprovals);
+    }
     const outputFormat = meta?.jsonSchema && this.options?.onStructuredOutput ? { type: "json_schema", schema: meta.jsonSchema } : void 0;
     this.logger.debug(isResume ? "Resuming session" : "Creating new session", {
       sessionId,
@@ -19157,6 +19267,11 @@ var HandoffCheckpointTracker = class {
         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);
@@ -19203,22 +19318,22 @@ var HandoffCheckpointTracker = class {
     };
   }
   async uploadArtifacts(specs) {
-    const uploads = await Promise.all(
-      specs.map(async (spec) => {
-        if (!spec.filePath) {
-          return [spec.key, void 0];
-        }
-        return [
-          spec.key,
-          await this.uploadArtifactFile(
-            spec.filePath,
-            spec.name,
-            spec.contentType
-          )
-        ];
-      })
-    );
-    return Object.fromEntries(uploads);
+    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) {
@@ -19230,7 +19345,7 @@ var HandoffCheckpointTracker = class {
       artifactPath
     );
     if (!arrayBuffer) {
-      throw new Error(`Failed to download ${label}`);
+      throw new Error(`Failed to download ${label} from ${artifactPath}`);
     }
     const base64Content = Buffer.from(arrayBuffer).toString("utf-8");
     const binaryContent = Buffer.from(base64Content, "base64");
@@ -19414,6 +19529,13 @@ var PostHogAPIClient = class {
       `/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(
@@ -19561,1215 +19683,1180 @@ function selectRecentTurns(turns, maxTokens = DEFAULT_MAX_TOKENS) {
   return turns.slice(startIndex);
 }
 
-// src/sagas/apply-snapshot-saga.ts
-import { mkdir as mkdir7, rm as rm6, writeFile as writeFile5 } from "fs/promises";
-import { join as join12 } from "path";
-
-// ../git/dist/sagas/tree.js
-import { existsSync as existsSync5 } from "fs";
-import * as fs12 from "fs/promises";
-import * as path15 from "path";
-import * as tar from "tar";
-var CaptureTreeSaga = class extends GitSaga {
-  sagaName = "CaptureTreeSaga";
-  tempIndexPath = null;
-  async executeGitOperations(input) {
-    const { baseDir, lastTreeHash, archivePath, signal } = input;
-    const tmpDir = path15.join(baseDir, ".git", "posthog-code-tmp");
-    await this.step({
-      name: "create_tmp_dir",
-      execute: () => fs12.mkdir(tmpDir, { recursive: true }),
-      rollback: async () => {
-      }
-    });
-    this.tempIndexPath = path15.join(tmpDir, `index-${Date.now()}`);
-    const tempIndexGit = this.git.env({
-      ...process.env,
-      GIT_INDEX_FILE: this.tempIndexPath
-    });
-    await this.step({
-      name: "init_temp_index",
-      execute: () => tempIndexGit.raw(["read-tree", "HEAD"]),
-      rollback: async () => {
-        if (this.tempIndexPath) {
-          await fs12.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 fs12.rm(this.tempIndexPath, { force: true }).catch(() => {
-      });
-      return { snapshot: null, changed: false };
+// 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 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 fs12.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);
+    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("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;
+    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
+      });
     }
-    const existingFiles = filesToArchive.filter((f) => existsSync5(path15.join(baseDir, f)));
-    if (existingFiles.length === 0) {
-      return void 0;
+    if (latestGitCheckpoint) {
+      this.log.info("Found git checkpoint", {
+        checkpointId: latestGitCheckpoint.checkpointId,
+        branch: latestGitCheckpoint.branch
+      });
     }
-    await this.step({
-      name: "create_archive",
-      execute: async () => {
-        const archiveDir = path15.dirname(archivePath);
-        await fs12.mkdir(archiveDir, { recursive: true });
-        await tar.create({
-          gzip: true,
-          file: archivePath,
-          cwd: baseDir
-        }, existingFiles);
-      },
-      rollback: async () => {
-        await fs12.rm(archivePath, { force: true }).catch(() => {
-        });
-      }
+    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 archivePath;
+    return {
+      conversation,
+      latestSnapshot,
+      latestGitCheckpoint,
+      interrupted: latestSnapshot?.interrupted ?? false,
+      lastDevice,
+      logEntryCount: entries.length
+    };
   }
-  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";
+  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;
+        }
       }
-      changes.push({ path: filePath, status: normalizedStatus });
     }
-    return changes;
+    return null;
   }
-};
-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;
+  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;
+        }
       }
-      try {
-        branch = await this.git.raw(["symbolic-ref", "--short", "HEAD"]);
-      } catch {
-        branch = null;
+    }
+    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 { 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);
+    }
+    return void 0;
+  }
+  rebuildConversation(entries) {
+    const turns = [];
+    let currentAssistantContent = [];
+    let currentToolCalls = [];
+    for (const entry of entries) {
+      const method = entry.notification?.method;
+      const params = entry.notification?.params;
+      if (method === "session/update" && params?.update) {
+        const update = params.update;
+        const sessionUpdate = update.sessionUpdate;
+        switch (sessionUpdate) {
+          case "user_message":
+          case "user_message_chunk": {
+            if (currentAssistantContent.length > 0 || currentToolCalls.length > 0) {
+              turns.push({
+                role: "assistant",
+                content: currentAssistantContent,
+                toolCalls: currentToolCalls.length > 0 ? currentToolCalls : void 0
+              });
+              currentAssistantContent = [];
+              currentToolCalls = [];
             }
-          } catch (error) {
-            this.log.warn("Failed to rollback checkout", { error });
+            const content = update.content;
+            const contentArray = Array.isArray(content) ? content : [content];
+            turns.push({
+              role: "user",
+              content: contentArray
+            });
+            break;
           }
-        }
-      });
-    }
-    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 = path15.join(baseDir, filePath);
-          try {
-            const content = await fs12.readFile(fullPath);
-            this.fileBackups.set(filePath, content);
-          } catch {
+          case "agent_message": {
+            const content = update.content;
+            if (content) {
+              if (content.type === "text" && currentAssistantContent.length > 0 && currentAssistantContent[currentAssistantContent.length - 1].type === "text") {
+                const lastBlock = currentAssistantContent[currentAssistantContent.length - 1];
+                lastBlock.text += content.text;
+              } else {
+                currentAssistantContent.push(content);
+              }
+            }
+            break;
           }
-        }
-      });
-      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 = path15.join(baseDir, filePath);
-            const backup = this.fileBackups.get(filePath);
-            if (backup) {
-              const dir = path15.dirname(fullPath);
-              await fs12.mkdir(dir, { recursive: true }).catch(() => {
-              });
-              await fs12.writeFile(fullPath, backup).catch(() => {
-              });
-            } else {
-              await fs12.rm(fullPath, { force: true }).catch(() => {
-              });
+          case "agent_message_chunk": {
+            const content = update.content;
+            if (content) {
+              if (content.type === "text" && currentAssistantContent.length > 0 && currentAssistantContent[currentAssistantContent.length - 1].type === "text") {
+                const lastBlock = currentAssistantContent[currentAssistantContent.length - 1];
+                lastBlock.text += content.text;
+              } else {
+                currentAssistantContent.push(content);
+              }
             }
+            break;
           }
-        }
-      });
-    }
-    for (const change of changes.filter((c) => c.status === "D")) {
-      const fullPath = path15.join(baseDir, change.path);
-      const backupContent = await this.readOnlyStep(`backup_${change.path}`, async () => {
-        try {
-          return await fs12.readFile(fullPath);
-        } catch {
-          return null;
-        }
-      });
-      await this.step({
-        name: `delete_${change.path}`,
-        execute: async () => {
-          await fs12.rm(fullPath, { force: true });
-          this.log.debug(`Deleted file: ${change.path}`);
-        },
-        rollback: async () => {
-          if (backupContent) {
-            const dir = path15.dirname(fullPath);
-            await fs12.mkdir(dir, { recursive: true }).catch(() => {
-            });
-            await fs12.writeFile(fullPath, backupContent).catch(() => {
-            });
+          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
       });
     }
-    const deletedCount = changes.filter((c) => c.status === "D").length;
-    this.log.info("Tree applied", {
-      treeHash,
-      totalChanges: changes.length,
-      deletedFiles: deletedCount,
-      checkoutPerformed
-    });
-    return { treeHash, checkoutPerformed };
+    return turns;
   }
 };
 
-// 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;
-    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
+// 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
     });
-    if (!applyResult.success) {
-      throw new Error(`Failed to apply tree: ${applyResult.error}`);
+    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}`);
     }
-    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 };
   }
-};
+  return parts2.join("\n\n");
+}
 
-// 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 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}`);
+// 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));
     }
-    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 };
+    await Promise.all(flushPromises);
+  }
+  register(sessionId, context) {
+    if (this.sessions.has(sessionId)) {
+      return;
     }
-    let archiveUrl;
-    if (apiClient && createdArchivePath) {
+    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 {
-        archiveUrl = await this.uploadArchive(
-          createdArchivePath,
-          gitSnapshot.treeHash,
-          apiClient,
-          taskId,
-          runId
-        );
-      } finally {
-        await rm7(createdArchivePath, { force: true }).catch(() => {
+        fs12.mkdirSync(sessionDir, { recursive: true });
+      } catch (error) {
+        this.logger.warn("Failed to create local cache directory", {
+          sessionDir,
+          error
         });
       }
     }
-    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 };
   }
-  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"
+  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;
           }
-        ]);
-        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;
       }
-    });
-    return archiveUrl;
-  }
-};
-
-// 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
+      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
       });
-      throw new Error(
-        `Failed to capture tree at step '${result.failedStep}': ${result.error}`
-      );
     }
-    if (result.data.newTreeHash !== null) {
-      this.lastTreeHash = result.data.newTreeHash;
+  }
+  async flush(sessionId, { coalesce = false } = {}) {
+    if (coalesce) {
+      const session = this.sessions.get(sessionId);
+      if (session) {
+        this.emitCoalescedMessage(sessionId, session);
+      }
     }
-    return result.data.snapshot;
+    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;
   }
-  /**
-   * 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");
+  async _doFlush(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      this.logger.warn("flush: no session found", { sessionId });
+      return;
     }
-    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 pending = this.pendingEntries.get(sessionId);
+    if (!this.posthogAPI || !pending?.length) {
+      return;
     }
-    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.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
+          }
+        );
+        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);
+      }
     }
-    this.lastTreeHash = result.data.treeHash;
   }
-  /**
-   * Get the last captured tree hash.
-   */
-  getLastTreeHash() {
-    return this.lastTreeHash;
+  getSessionUpdateType(message) {
+    if (message.method !== "session/update") return void 0;
+    const params = message.params;
+    const update = params?.update;
+    return update?.sessionUpdate;
   }
-  /**
-   * Set the last tree hash (used when resuming).
-   */
-  setLastTreeHash(hash) {
-    this.lastTreeHash = hash;
+  isDirectAgentMessage(message) {
+    return this.getSessionUpdateType(message) === "agent_message";
   }
-};
-
-// 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();
+  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;
     }
-    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();
+    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);
     }
-    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))
-    );
-    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
-              }
-            );
-          }
-        },
-        rollback: async () => {
-        }
-      });
-    } else if (latestSnapshot?.archiveUrl && !repositoryPath) {
-      this.log.warn(
-        "Snapshot found but no repositoryPath configured - files cannot be restored",
+  }
+  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",
         {
-          treeHash: latestSnapshot.treeHash,
-          changes: latestSnapshot.changes?.length ?? 0
+          sessionId,
+          bufferedLength: session.chunkBuffer.text.length
         }
       );
-    } else if (latestSnapshot) {
-      this.log.warn(
-        "Snapshot found but has no archive URL - files cannot be restored",
-        {
-          treeHash: latestSnapshot.treeHash,
-          changes: latestSnapshot.changes?.length ?? 0
-        }
+    }
+    return session.currentTurnMessages.join("\n\n");
+  }
+  resetTurnMessages(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.currentTurnMessages = [];
+    }
+  }
+  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;
+  }
+  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;
     }
-    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,
-      latestGitCheckpoint,
-      snapshotApplied,
-      interrupted: latestSnapshot?.interrupted ?? false,
-      lastDevice,
-      logEntryCount: entries.length
-    };
+    const timeout = setTimeout(() => this.flush(sessionId), delay3);
+    this.flushTimeouts.set(sessionId, timeout);
   }
-  emptyResult() {
-    return {
-      conversation: [],
-      latestSnapshot: null,
-      latestGitCheckpoint: null,
-      snapshotApplied: false,
-      interrupted: false,
-      logEntryCount: 0
-    };
+  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
+      });
+    }
   }
-  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;
+  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 {
         }
       }
+    } catch {
     }
-    return null;
+    return deleted;
   }
-  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;
+};
+
+// 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 };
     }
-    return null;
+    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 };
   }
-  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;
+  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" }));
     }
-    return 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 {
+        normalizedStatus = "M";
+      }
+      changes.push({ path: filePath, status: normalizedStatus });
+    }
+    return changes;
   }
-  rebuildConversation(entries) {
-    const turns = [];
-    let currentAssistantContent = [];
-    let currentToolCalls = [];
-    for (const entry of entries) {
-      const method = entry.notification?.method;
-      const params = entry.notification?.params;
-      if (method === "session/update" && params?.update) {
-        const update = params.update;
-        const sessionUpdate = update.sessionUpdate;
-        switch (sessionUpdate) {
-          case "user_message":
-          case "user_message_chunk": {
-            if (currentAssistantContent.length > 0 || currentToolCalls.length > 0) {
-              turns.push({
-                role: "assistant",
-                content: currentAssistantContent,
-                toolCalls: currentToolCalls.length > 0 ? currentToolCalls : void 0
-              });
-              currentAssistantContent = [];
-              currentToolCalls = [];
-            }
-            const content = update.content;
-            const contentArray = Array.isArray(content) ? content : [content];
-            turns.push({
-              role: "user",
-              content: contentArray
-            });
-            break;
-          }
-          case "agent_message": {
-            const content = update.content;
-            if (content) {
-              if (content.type === "text" && currentAssistantContent.length > 0 && currentAssistantContent[currentAssistantContent.length - 1].type === "text") {
-                const lastBlock = currentAssistantContent[currentAssistantContent.length - 1];
-                lastBlock.text += content.text;
-              } else {
-                currentAssistantContent.push(content);
-              }
-            }
-            break;
-          }
-          case "agent_message_chunk": {
-            const content = update.content;
-            if (content) {
-              if (content.type === "text" && currentAssistantContent.length > 0 && currentAssistantContent[currentAssistantContent.length - 1].type === "text") {
-                const lastBlock = currentAssistantContent[currentAssistantContent.length - 1];
-                lastBlock.text += content.text;
-              } else {
-                currentAssistantContent.push(content);
-              }
-            }
-            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;
-                }
-              }
+};
+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);
             }
-            break;
+          } catch (error) {
+            this.log.warn("Failed to rollback checkout", { 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;
-                }
-              }
+        }
+      });
+    }
+    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(() => {
+              });
             }
-            break;
           }
         }
-      }
+      });
     }
-    if (currentAssistantContent.length > 0 || currentToolCalls.length > 0) {
-      turns.push({
-        role: "assistant",
-        content: currentAssistantContent,
-        toolCalls: currentToolCalls.length > 0 ? currentToolCalls : void 0
+    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(() => {
+            });
+          }
+        }
       });
     }
-    return turns;
+    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/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,
-    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)*`
-    );
-  }
-  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")}`);
+// 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");
     }
-    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 archiveUrl = snapshot.archiveUrl;
+    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");
         }
-        return `  - ${tc.toolName}${resultStr}`;
-      }).join("\n");
-      parts2.push(`**${role} (tools)**:
-${toolSummary}`);
-    }
-  }
-  return parts2.join("\n\n");
-}
-
-// src/session-log-writer.ts
-import fs13 from "fs";
-import fsp from "fs/promises";
-import path16 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 = path16.join(
-        this.localCachePath,
-        "sessions",
-        context.runId
-      );
-      try {
-        fs13.mkdirSync(sessionDir, { recursive: true });
-      } catch (error) {
-        this.logger.warn("Failed to create local cache directory", {
-          sessionDir,
-          error
+        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
         });
-      }
-    }
-  }
-  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;
-          }
+      },
+      rollback: async () => {
+        if (this.archivePath) {
+          await rm6(this.archivePath, { force: true }).catch(() => {
+          });
         }
-        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 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}`);
     }
-    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);
-      }
+    await rm6(this.archivePath, { force: true }).catch(() => {
     });
-    return next;
+    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 = path16.join(
-      this.localCachePath,
-      "sessions",
-      session.context.runId,
-      "logs.ndjson"
-    );
-    try {
-      fs13.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 = path16.join(localCachePath, "sessions");
-    let deleted = 0;
-    try {
-      const entries = await fsp.readdir(sessionsDir);
-      const now = Date.now();
-      for (const entry of entries) {
-        const entryPath = path16.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;
   }
 };
 
@@ -21245,45 +21332,29 @@ var AgentServer = class {
     });
     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...");
@@ -21682,29 +21753,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) {
@@ -21763,8 +21816,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 = [
@@ -21805,7 +21909,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);
@@ -21969,6 +22075,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;