@posthog/agent 2.3.5 → 2.3.11

package/dist/server/agent-server.js

@@ -513,7 +513,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os5 = __require("os");
+    var os6 = __require("os");
     var tty = __require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -561,7 +561,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os5.release().split(".");
+        const osRelease = os6.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -809,10 +809,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log = debug_1.default("@kwsites/file-exists");
-    function check(path10, isFile, isDirectory) {
-      log(`checking %s`, path10);
+    function check(path11, isFile, isDirectory) {
+      log(`checking %s`, path11);
       try {
-        const stat = fs_1.statSync(path10);
+        const stat = fs_1.statSync(path11);
         if (stat.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
@@ -832,8 +832,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path10, type = exports.READABLE) {
-      return check(path10, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path11, type = exports.READABLE) {
+      return check(path11, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -908,7 +908,7 @@ import { Hono } from "hono";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.5",
+  version: "2.3.11",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -1033,6 +1033,8 @@ var POSTHOG_NOTIFICATIONS = {
   RUN_STARTED: "_posthog/run_started",
   /** Task has completed (success or failure) */
   TASK_COMPLETE: "_posthog/task_complete",
+  /** Agent finished processing a turn (prompt returned, waiting for next input) */
+  TURN_COMPLETE: "_posthog/turn_complete",
   /** Error occurred during task execution */
   ERROR: "_posthog/error",
   /** Console/log output from the agent */
@@ -1580,8 +1582,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path10, oldText, newText) {
-    this.items.push({ type: "diff", path: path10, oldText, newText });
+  diff(path11, oldText, newText) {
+    this.items.push({ type: "diff", path: path11, oldText, newText });
     return this;
   }
   build() {
@@ -2958,7 +2960,12 @@ var BASH_TOOLS = /* @__PURE__ */ new Set([
 ]);
 var SEARCH_TOOLS = /* @__PURE__ */ new Set(["Glob", "Grep", "LS"]);
 var WEB_TOOLS = /* @__PURE__ */ new Set(["WebSearch", "WebFetch"]);
-var AGENT_TOOLS = /* @__PURE__ */ new Set(["Task", "TodoWrite", "Skill"]);
+var AGENT_TOOLS = /* @__PURE__ */ new Set([
+  "Task",
+  "Agent",
+  "TodoWrite",
+  "Skill"
+]);
 var BASE_ALLOWED_TOOLS = [
   ...READ_TOOLS,
   ...SEARCH_TOOLS,
@@ -4993,6 +5000,45 @@ function createCodexConnection(config) {
   };
 }
 
+// src/adapters/claude/session/jsonl-hydration.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import * as fs4 from "fs/promises";
+import * as os5 from "os";
+import * as path6 from "path";
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_MAX_TOKENS = 15e4;
+function estimateTurnTokens(turn) {
+  let chars = 0;
+  for (const block of turn.content) {
+    if ("text" in block && typeof block.text === "string") {
+      chars += block.text.length;
+    }
+  }
+  if (turn.toolCalls) {
+    for (const tc of turn.toolCalls) {
+      chars += JSON.stringify(tc.input ?? "").length;
+      if (tc.result !== void 0) {
+        chars += typeof tc.result === "string" ? tc.result.length : JSON.stringify(tc.result).length;
+      }
+    }
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function selectRecentTurns(turns, maxTokens = DEFAULT_MAX_TOKENS) {
+  let budget = maxTokens;
+  let startIndex = turns.length;
+  for (let i = turns.length - 1; i >= 0; i--) {
+    const cost = estimateTurnTokens(turns[i]);
+    if (cost > budget) break;
+    budget -= cost;
+    startIndex = i;
+  }
+  while (startIndex < turns.length && turns[startIndex].role !== "user") {
+    startIndex++;
+  }
+  return turns.slice(startIndex);
+}
+
 // src/utils/gateway.ts
 function getLlmGatewayUrl(posthogHost, product = "posthog_code") {
   const url = new URL(posthogHost);
@@ -5176,330 +5222,165 @@ var PostHogAPIClient = class {
   }
 };
 
-// src/session-log-writer.ts
-import fs4 from "fs";
-import fsp from "fs/promises";
-import path6 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();
-  logger;
-  localCachePath;
-  constructor(options = {}) {
-    this.posthogAPI = options.posthogAPI;
-    this.localCachePath = options.localCachePath;
-    this.logger = options.logger ?? new Logger({ debug: false, prefix: "[SessionLogWriter]" });
+// ../shared/dist/index.js
+var consoleLogger = {
+  info: (_message, _data) => {
+  },
+  debug: (_message, _data) => {
+  },
+  error: (_message, _data) => {
+  },
+  warn: (_message, _data) => {
   }
-  async flushAll() {
-    const sessionIds = [...this.sessions.keys()];
-    const flushPromises = [];
-    for (const sessionId of sessionIds) {
-      flushPromises.push(this.flush(sessionId));
-    }
-    await Promise.all(flushPromises);
+};
+var Saga = class {
+  completedSteps = [];
+  currentStepName = "unknown";
+  stepTimings = [];
+  log;
+  constructor(logger) {
+    this.log = logger ?? consoleLogger;
   }
-  register(sessionId, context) {
-    if (this.sessions.has(sessionId)) {
-      return;
+  /**
+   * Run the saga with the given input.
+   * Returns a discriminated union result - either success with data or failure with error details.
+   */
+  async run(input) {
+    this.completedSteps = [];
+    this.currentStepName = "unknown";
+    this.stepTimings = [];
+    const sagaStart = performance.now();
+    this.log.info("Starting saga", { sagaName: this.sagaName });
+    try {
+      const result = await this.execute(input);
+      const totalDuration = performance.now() - sagaStart;
+      this.log.debug("Saga completed successfully", {
+        sagaName: this.sagaName,
+        stepsCompleted: this.completedSteps.length,
+        totalDurationMs: Math.round(totalDuration),
+        stepTimings: this.stepTimings
+      });
+      return { success: true, data: result };
+    } catch (error) {
+      this.log.error("Saga failed, initiating rollback", {
+        sagaName: this.sagaName,
+        failedStep: this.currentStepName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      await this.rollback();
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        failedStep: this.currentStepName
+      };
     }
-    this.logger.info("Session registered", {
-      taskId: context.taskId,
-      runId: context.runId
+  }
+  /**
+   * Execute a step with its rollback action.
+   * If the step succeeds, its rollback action is stored for potential rollback.
+   * The step name is automatically tracked for error reporting.
+   *
+   * @param config - Step configuration with name, execute, and rollback functions
+   * @returns The result of the execute function
+   * @throws Re-throws any error from the execute function (triggers rollback)
+   */
+  async step(config) {
+    this.currentStepName = config.name;
+    this.log.debug(`Executing step: ${config.name}`);
+    const stepStart = performance.now();
+    const result = await config.execute();
+    const durationMs = Math.round(performance.now() - stepStart);
+    this.stepTimings.push({ name: config.name, durationMs });
+    this.log.debug(`Step completed: ${config.name}`, { durationMs });
+    this.completedSteps.push({
+      name: config.name,
+      rollback: () => config.rollback(result)
     });
-    this.sessions.set(sessionId, { context });
-    this.lastFlushAttemptTime.set(sessionId, Date.now());
-    if (this.localCachePath) {
-      const sessionDir = path6.join(
-        this.localCachePath,
-        "sessions",
-        context.runId
-      );
+    return result;
+  }
+  /**
+   * Execute a step that doesn't need rollback.
+   * Useful for read-only operations or operations that are idempotent.
+   * The step name is automatically tracked for error reporting.
+   *
+   * @param name - Step name for logging and error tracking
+   * @param execute - The action to execute
+   * @returns The result of the execute function
+   */
+  async readOnlyStep(name, execute) {
+    this.currentStepName = name;
+    this.log.debug(`Executing read-only step: ${name}`);
+    const stepStart = performance.now();
+    const result = await execute();
+    const durationMs = Math.round(performance.now() - stepStart);
+    this.stepTimings.push({ name, durationMs });
+    this.log.debug(`Read-only step completed: ${name}`, { durationMs });
+    return result;
+  }
+  /**
+   * Roll back all completed steps in reverse order.
+   * Rollback errors are logged but don't stop the rollback of other steps.
+   */
+  async rollback() {
+    this.log.info("Rolling back saga", {
+      stepsToRollback: this.completedSteps.length
+    });
+    const stepsReversed = [...this.completedSteps].reverse();
+    for (const step of stepsReversed) {
       try {
-        fs4.mkdirSync(sessionDir, { recursive: true });
+        this.log.debug(`Rolling back step: ${step.name}`);
+        await step.rollback();
+        this.log.debug(`Step rolled back: ${step.name}`);
       } catch (error) {
-        this.logger.warn("Failed to create local cache directory", {
-          sessionDir,
-          error
+        this.log.error(`Failed to rollback step: ${step.name}`, {
+          error: error instanceof Error ? error.message : String(error)
         });
       }
     }
+    this.log.info("Rollback completed", {
+      stepsAttempted: this.completedSteps.length
+    });
   }
-  isRegistered(sessionId) {
-    return this.sessions.has(sessionId);
+  /**
+   * Get the number of completed steps (useful for testing)
+   */
+  getCompletedStepCount() {
+    return this.completedSteps.length;
   }
-  appendRawLine(sessionId, line) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      this.logger.warn("appendRawLine called for unregistered session", {
-        sessionId
-      });
-      return;
-    }
-    try {
-      const message = JSON.parse(line);
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      if (this.isAgentMessageChunk(message)) {
-        const text2 = this.extractChunkText(message);
-        if (text2) {
-          if (!session.chunkBuffer) {
-            session.chunkBuffer = { text: text2, firstTimestamp: timestamp };
-          } else {
-            session.chunkBuffer.text += text2;
-          }
-        }
-        return;
-      }
-      this.emitCoalescedMessage(sessionId, session);
-      const nonChunkAgentText = this.extractAgentMessageText(message);
-      if (nonChunkAgentText) {
-        session.lastAgentMessage = 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) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      this.logger.warn("flush: no session found", { sessionId });
-      return;
-    }
-    this.emitCoalescedMessage(sessionId, session);
-    const pending = this.pendingEntries.get(sessionId);
-    if (!this.posthogAPI || !pending?.length) {
-      return;
-    }
-    this.pendingEntries.delete(sessionId);
-    const timeout = this.flushTimeouts.get(sessionId);
-    if (timeout) {
-      clearTimeout(timeout);
-      this.flushTimeouts.delete(sessionId);
-    }
-    this.lastFlushAttemptTime.set(sessionId, Date.now());
-    try {
-      await this.posthogAPI.appendTaskRunLog(
-        session.context.taskId,
-        session.context.runId,
-        pending
-      );
-      this.retryCounts.set(sessionId, 0);
-    } catch (error) {
-      const retryCount = (this.retryCounts.get(sessionId) ?? 0) + 1;
-      this.retryCounts.set(sessionId, retryCount);
-      if (retryCount >= _SessionLogWriter.MAX_FLUSH_RETRIES) {
-        this.logger.error(
-          `Dropping ${pending.length} session log entries after ${retryCount} failed flush attempts`,
-          {
-            taskId: session.context.taskId,
-            runId: session.context.runId,
-            error
-          }
-        );
-        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);
-      }
-    }
-  }
-  isAgentMessageChunk(message) {
-    if (message.method !== "session/update") return false;
-    const params = message.params;
-    const update = params?.update;
-    return update?.sessionUpdate === "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;
-    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);
-    }
-  }
-  getLastAgentMessage(sessionId) {
-    return this.sessions.get(sessionId)?.lastAgentMessage;
-  }
-  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 timeout = setTimeout(() => this.flush(sessionId), delay3);
-    this.flushTimeouts.set(sessionId, timeout);
-  }
-  writeToLocalCache(sessionId, entry) {
-    if (!this.localCachePath) return;
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    const logPath = path6.join(
-      this.localCachePath,
-      "sessions",
-      session.context.runId,
-      "logs.ndjson"
-    );
-    try {
-      fs4.appendFileSync(logPath, `${JSON.stringify(entry)}
-`);
-    } catch (error) {
-      this.logger.warn("Failed to write to local cache", {
-        taskId: session.context.taskId,
-        runId: session.context.runId,
-        logPath,
-        error
-      });
-    }
-  }
-  static async cleanupOldSessions(localCachePath) {
-    const sessionsDir = path6.join(localCachePath, "sessions");
-    let deleted = 0;
-    try {
-      const entries = await fsp.readdir(sessionsDir);
-      const now = Date.now();
-      for (const entry of entries) {
-        const entryPath = path6.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;
-  }
-};
-
-// ../git/dist/queries.js
-import * as fs6 from "fs/promises";
-import * as path8 from "path";
-
-// ../../node_modules/simple-git/dist/esm/index.js
-var import_file_exists = __toESM(require_dist(), 1);
-var import_debug = __toESM(require_src(), 1);
-var import_promise_deferred = __toESM(require_dist2(), 1);
-var import_promise_deferred2 = __toESM(require_dist2(), 1);
-import { Buffer as Buffer2 } from "buffer";
-import { spawn as spawn3 } from "child_process";
-import { normalize as normalize2 } from "path";
-import { EventEmitter } from "events";
-var __defProp2 = Object.defineProperty;
-var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames2 = Object.getOwnPropertyNames;
-var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
-};
-var __commonJS2 = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp2(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps2 = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames2(from))
-      if (!__hasOwnProp2.call(to, key) && key !== except)
-        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+};
+
+// ../git/dist/queries.js
+import * as fs6 from "fs/promises";
+import * as path8 from "path";
+
+// ../../node_modules/simple-git/dist/esm/index.js
+var import_file_exists = __toESM(require_dist(), 1);
+var import_debug = __toESM(require_src(), 1);
+var import_promise_deferred = __toESM(require_dist2(), 1);
+var import_promise_deferred2 = __toESM(require_dist2(), 1);
+import { Buffer as Buffer2 } from "buffer";
+import { spawn as spawn3 } from "child_process";
+import { normalize as normalize2 } from "path";
+import { EventEmitter } from "events";
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+};
+var __commonJS2 = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
   }
   return to;
 };
@@ -5509,8 +5390,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path10) {
-  return path10 instanceof String && cache.has(path10);
+function isPathSpec(path11) {
+  return path11 instanceof String && cache.has(path11);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -5599,8 +5480,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path10) {
-  return (0, import_file_exists.exists)(path10, import_file_exists.FOLDER);
+function folderExists(path11) {
+  return (0, import_file_exists.exists)(path11, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -6004,8 +5885,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path10) {
-      return /^\.(git)?$/.test(path10.trim());
+    parser(path11) {
+      return /^\.(git)?$/.test(path11.trim());
     }
   };
 }
@@ -6439,11 +6320,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path10, line, preview] = input.split(NULL);
-    paths.add(path10);
-    (results[path10] = results[path10] || []).push({
+    const [path11, line, preview] = input.split(NULL);
+    paths.add(path11);
+    (results[path11] = results[path11] || []).push({
       line: asNumber(line),
-      path: path10,
+      path: path11,
       preview
     });
   });
@@ -7208,14 +7089,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path10, text2) {
+function parseInit(bare, path11, text2) {
   const response = String(text2).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path10, false, result[1]);
+    return new InitSummary(bare, path11, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path10, true, result[1]);
+    return new InitSummary(bare, path11, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -7226,7 +7107,7 @@ function parseInit(bare, path10, text2) {
       break;
     }
   }
-  return new InitSummary(bare, path10, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path11, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -7235,9 +7116,9 @@ var init_InitSummary = __esm({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path10, existing, gitDir) {
+      constructor(bare, path11, existing, gitDir) {
         this.bare = bare;
-        this.path = path10;
+        this.path = path11;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -7249,7 +7130,7 @@ var init_InitSummary = __esm({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path10, customArgs) {
+function initTask(bare = false, path11, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -7258,7 +7139,7 @@ function initTask(bare = false, path10, customArgs) {
     commands,
     format: "utf-8",
     parser(text2) {
-      return parseInit(commands.includes("--bare"), path10, text2);
+      return parseInit(commands.includes("--bare"), path11, text2);
     }
   };
 }
@@ -8074,12 +7955,12 @@ var init_FileStatusSummary = __esm({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path10, index, working_dir) {
-        this.path = path10;
+      constructor(path11, index, working_dir) {
+        this.path = path11;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path10) || [null, path10, path10];
+          const detail = fromPathRegex.exec(path11) || [null, path11, path11];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -8110,14 +7991,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path10) {
+  function data(index, workingDir, path11) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path10);
+      handler(result, path11);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path10, index, workingDir));
+      result.files.push(new FileStatusSummary(path11, index, workingDir));
     }
   }
 }
@@ -8430,9 +8311,9 @@ var init_simple_git_api = __esm({
           next
         );
       }
-      hashObject(path10, write) {
+      hashObject(path11, write) {
         return this._runTask(
-          hashObjectTask(path10, write === true),
+          hashObjectTask(path11, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -8785,8 +8666,8 @@ var init_branch = __esm({
   }
 });
 function toPath(input) {
-  const path10 = input.trim().replace(/^["']|["']$/g, "");
-  return path10 && normalize2(path10);
+  const path11 = input.trim().replace(/^["']|["']$/g, "");
+  return path11 && normalize2(path11);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
@@ -9100,8 +8981,8 @@ __export(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path10) {
-  return subModuleTask(["add", repo, path10]);
+function addSubModuleTask(repo, path11) {
+  return subModuleTask(["add", repo, path11]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -9431,8 +9312,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path10, then) {
-      return this._runTask(addSubModuleTask2(repo, path10), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path11, then) {
+      return this._runTask(addSubModuleTask2(repo, path11), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -10225,8 +10106,8 @@ async function getHeadSha(baseDir, options) {
 }
 
 // src/sagas/apply-snapshot-saga.ts
-import { mkdir as mkdir3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
-import { join as join6 } from "path";
+import { mkdir as mkdir4, rm as rm3, writeFile as writeFile4 } from "fs/promises";
+import { join as join7 } from "path";
 
 // ../git/dist/sagas/tree.js
 import { existsSync as existsSync4 } from "fs";
@@ -10234,148 +10115,21 @@ import * as fs7 from "fs/promises";
 import * as path9 from "path";
 import * as tar from "tar";
 
-// ../shared/dist/index.js
-var consoleLogger = {
-  info: (_message, _data) => {
-  },
-  debug: (_message, _data) => {
-  },
-  error: (_message, _data) => {
-  },
-  warn: (_message, _data) => {
+// ../git/dist/git-saga.js
+var GitSaga = class extends Saga {
+  _git = null;
+  get git() {
+    if (!this._git) {
+      throw new Error("git client accessed before execute() was called");
+    }
+    return this._git;
   }
-};
-var Saga = class {
-  completedSteps = [];
-  currentStepName = "unknown";
-  stepTimings = [];
-  log;
-  constructor(logger) {
-    this.log = logger ?? consoleLogger;
-  }
-  /**
-   * Run the saga with the given input.
-   * Returns a discriminated union result - either success with data or failure with error details.
-   */
-  async run(input) {
-    this.completedSteps = [];
-    this.currentStepName = "unknown";
-    this.stepTimings = [];
-    const sagaStart = performance.now();
-    this.log.info("Starting saga", { sagaName: this.sagaName });
-    try {
-      const result = await this.execute(input);
-      const totalDuration = performance.now() - sagaStart;
-      this.log.debug("Saga completed successfully", {
-        sagaName: this.sagaName,
-        stepsCompleted: this.completedSteps.length,
-        totalDurationMs: Math.round(totalDuration),
-        stepTimings: this.stepTimings
-      });
-      return { success: true, data: result };
-    } catch (error) {
-      this.log.error("Saga failed, initiating rollback", {
-        sagaName: this.sagaName,
-        failedStep: this.currentStepName,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      await this.rollback();
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        failedStep: this.currentStepName
-      };
-    }
-  }
-  /**
-   * Execute a step with its rollback action.
-   * If the step succeeds, its rollback action is stored for potential rollback.
-   * The step name is automatically tracked for error reporting.
-   *
-   * @param config - Step configuration with name, execute, and rollback functions
-   * @returns The result of the execute function
-   * @throws Re-throws any error from the execute function (triggers rollback)
-   */
-  async step(config) {
-    this.currentStepName = config.name;
-    this.log.debug(`Executing step: ${config.name}`);
-    const stepStart = performance.now();
-    const result = await config.execute();
-    const durationMs = Math.round(performance.now() - stepStart);
-    this.stepTimings.push({ name: config.name, durationMs });
-    this.log.debug(`Step completed: ${config.name}`, { durationMs });
-    this.completedSteps.push({
-      name: config.name,
-      rollback: () => config.rollback(result)
-    });
-    return result;
-  }
-  /**
-   * Execute a step that doesn't need rollback.
-   * Useful for read-only operations or operations that are idempotent.
-   * The step name is automatically tracked for error reporting.
-   *
-   * @param name - Step name for logging and error tracking
-   * @param execute - The action to execute
-   * @returns The result of the execute function
-   */
-  async readOnlyStep(name, execute) {
-    this.currentStepName = name;
-    this.log.debug(`Executing read-only step: ${name}`);
-    const stepStart = performance.now();
-    const result = await execute();
-    const durationMs = Math.round(performance.now() - stepStart);
-    this.stepTimings.push({ name, durationMs });
-    this.log.debug(`Read-only step completed: ${name}`, { durationMs });
-    return result;
-  }
-  /**
-   * Roll back all completed steps in reverse order.
-   * Rollback errors are logged but don't stop the rollback of other steps.
-   */
-  async rollback() {
-    this.log.info("Rolling back saga", {
-      stepsToRollback: this.completedSteps.length
-    });
-    const stepsReversed = [...this.completedSteps].reverse();
-    for (const step of stepsReversed) {
-      try {
-        this.log.debug(`Rolling back step: ${step.name}`);
-        await step.rollback();
-        this.log.debug(`Step rolled back: ${step.name}`);
-      } catch (error) {
-        this.log.error(`Failed to rollback step: ${step.name}`, {
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-    this.log.info("Rollback completed", {
-      stepsAttempted: this.completedSteps.length
-    });
-  }
-  /**
-   * Get the number of completed steps (useful for testing)
-   */
-  getCompletedStepCount() {
-    return this.completedSteps.length;
-  }
-};
-
-// ../git/dist/git-saga.js
-var GitSaga = class extends Saga {
-  _git = null;
-  get git() {
-    if (!this._git) {
-      throw new Error("git client accessed before execute() was called");
-    }
-    return this._git;
-  }
-  async execute(input) {
-    const manager = getGitOperationManager();
-    return manager.executeWrite(input.baseDir, async (git) => {
-      this._git = git;
-      return this.executeGitOperations(input);
-    }, { signal: input.signal });
+  async execute(input) {
+    const manager = getGitOperationManager();
+    return manager.executeWrite(input.baseDir, async (git) => {
+      this._git = git;
+      return this.executeGitOperations(input);
+    }, { signal: input.signal });
   }
 };
 
@@ -10641,18 +10395,18 @@ var ApplySnapshotSaga = class extends Saga {
   archivePath = null;
   async execute(input) {
     const { snapshot, repositoryPath, apiClient, taskId, runId } = input;
-    const tmpDir = join6(repositoryPath, ".posthog", "tmp");
+    const tmpDir = join7(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: () => mkdir3(tmpDir, { recursive: true }),
+      execute: () => mkdir4(tmpDir, { recursive: true }),
       rollback: async () => {
       }
     });
-    const archivePath = join6(tmpDir, `${snapshot.treeHash}.tar.gz`);
+    const archivePath = join7(tmpDir, `${snapshot.treeHash}.tar.gz`);
     this.archivePath = archivePath;
     await this.step({
       name: "download_archive",
@@ -10667,7 +10421,7 @@ var ApplySnapshotSaga = class extends Saga {
         }
         const base64Content = Buffer.from(arrayBuffer).toString("utf-8");
         const binaryContent = Buffer.from(base64Content, "base64");
-        await writeFile3(archivePath, binaryContent);
+        await writeFile4(archivePath, binaryContent);
       },
       rollback: async () => {
         if (this.archivePath) {
@@ -10701,7 +10455,7 @@ var ApplySnapshotSaga = class extends Saga {
 // src/sagas/capture-tree-saga.ts
 import { existsSync as existsSync5 } from "fs";
 import { readFile as readFile3, rm as rm4 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var CaptureTreeSaga2 = class extends Saga {
   sagaName = "CaptureTreeSaga";
   async execute(input) {
@@ -10713,14 +10467,14 @@ var CaptureTreeSaga2 = class extends Saga {
       taskId,
       runId
     } = input;
-    const tmpDir = join7(repositoryPath, ".posthog", "tmp");
-    if (existsSync5(join7(repositoryPath, ".gitmodules"))) {
+    const tmpDir = join8(repositoryPath, ".posthog", "tmp");
+    if (existsSync5(join8(repositoryPath, ".gitmodules"))) {
       this.log.warn(
         "Repository has submodules - snapshot may not capture submodule state"
       );
     }
     const shouldArchive = !!apiClient;
-    const archivePath = shouldArchive ? join7(tmpDir, `tree-${Date.now()}.tar.gz`) : void 0;
+    const archivePath = shouldArchive ? join8(tmpDir, `tree-${Date.now()}.tar.gz`) : void 0;
     const gitCaptureSaga = new CaptureTreeSaga(this.log);
     const captureResult = await gitCaptureSaga.run({
       baseDir: repositoryPath,
@@ -10841,57 +10595,632 @@ var TreeTracker = class {
         `Failed to capture tree at step '${result.failedStep}': ${result.error}`
       );
     }
-    if (result.data.newTreeHash !== null) {
-      this.lastTreeHash = result.data.newTreeHash;
+    if (result.data.newTreeHash !== null) {
+      this.lastTreeHash = result.data.newTreeHash;
+    }
+    return result.data.snapshot;
+  }
+  /**
+   * Download and apply a tree snapshot.
+   * Uses Saga pattern for atomic operation with rollback on failure.
+   */
+  async applyTreeSnapshot(snapshot) {
+    if (!this.apiClient) {
+      throw new Error("Cannot apply snapshot: API client not configured");
+    }
+    if (!snapshot.archiveUrl) {
+      this.logger.warn("Cannot apply snapshot: no archive URL", {
+        treeHash: snapshot.treeHash,
+        changes: snapshot.changes.length
+      });
+      throw new Error("Cannot apply snapshot: no archive URL");
+    }
+    const saga = new ApplySnapshotSaga(this.logger);
+    const result = await saga.run({
+      snapshot,
+      repositoryPath: this.repositoryPath,
+      apiClient: this.apiClient,
+      taskId: this.taskId,
+      runId: this.runId
+    });
+    if (!result.success) {
+      this.logger.error("Failed to apply tree snapshot", {
+        error: result.error,
+        failedStep: result.failedStep,
+        treeHash: snapshot.treeHash
+      });
+      throw new Error(
+        `Failed to apply snapshot at step '${result.failedStep}': ${result.error}`
+      );
+    }
+    this.lastTreeHash = result.data.treeHash;
+  }
+  /**
+   * Get the last captured tree hash.
+   */
+  getLastTreeHash() {
+    return this.lastTreeHash;
+  }
+  /**
+   * Set the last tree hash (used when resuming).
+   */
+  setLastTreeHash(hash) {
+    this.lastTreeHash = hash;
+  }
+};
+
+// src/sagas/resume-saga.ts
+var ResumeSaga = class extends Saga {
+  sagaName = "ResumeSaga";
+  async execute(input) {
+    const { taskId, runId, repositoryPath, apiClient } = input;
+    const logger = input.logger || new Logger({ debug: false, prefix: "[Resume]" });
+    const taskRun = await this.readOnlyStep(
+      "fetch_task_run",
+      () => apiClient.getTaskRun(taskId, runId)
+    );
+    if (!taskRun.log_url) {
+      this.log.info("No log URL found, starting fresh");
+      return this.emptyResult();
+    }
+    const entries = await this.readOnlyStep(
+      "fetch_logs",
+      () => apiClient.fetchTaskRunLogs(taskRun)
+    );
+    if (entries.length === 0) {
+      this.log.info("No log entries found, starting fresh");
+      return this.emptyResult();
+    }
+    this.log.info("Fetched log entries", { count: entries.length });
+    const latestSnapshot = await this.readOnlyStep(
+      "find_snapshot",
+      () => Promise.resolve(this.findLatestTreeSnapshot(entries))
+    );
+    let snapshotApplied = false;
+    if (latestSnapshot?.archiveUrl && repositoryPath) {
+      this.log.info("Found tree snapshot", {
+        treeHash: latestSnapshot.treeHash,
+        hasArchiveUrl: true,
+        changes: latestSnapshot.changes?.length ?? 0,
+        interrupted: latestSnapshot.interrupted
+      });
+      await this.step({
+        name: "apply_snapshot",
+        execute: async () => {
+          const treeTracker = new TreeTracker({
+            repositoryPath,
+            taskId,
+            runId,
+            apiClient,
+            logger: logger.child("TreeTracker")
+          });
+          try {
+            await treeTracker.applyTreeSnapshot(latestSnapshot);
+            treeTracker.setLastTreeHash(latestSnapshot.treeHash);
+            snapshotApplied = true;
+            this.log.info("Tree snapshot applied successfully", {
+              treeHash: latestSnapshot.treeHash
+            });
+          } catch (error) {
+            this.log.warn(
+              "Failed to apply tree snapshot, continuing without it",
+              {
+                error: error instanceof Error ? error.message : String(error),
+                treeHash: latestSnapshot.treeHash
+              }
+            );
+          }
+        },
+        rollback: async () => {
+        }
+      });
+    } else if (latestSnapshot?.archiveUrl && !repositoryPath) {
+      this.log.warn(
+        "Snapshot found but no repositoryPath configured - files cannot be restored",
+        {
+          treeHash: latestSnapshot.treeHash,
+          changes: latestSnapshot.changes?.length ?? 0
+        }
+      );
+    } 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
+        }
+      );
+    }
+    const conversation = await this.readOnlyStep(
+      "rebuild_conversation",
+      () => Promise.resolve(this.rebuildConversation(entries))
+    );
+    const lastDevice = await this.readOnlyStep(
+      "find_device",
+      () => Promise.resolve(this.findLastDeviceInfo(entries))
+    );
+    this.log.info("Resume state rebuilt", {
+      turns: conversation.length,
+      hasSnapshot: !!latestSnapshot,
+      snapshotApplied,
+      interrupted: latestSnapshot?.interrupted ?? false
+    });
+    return {
+      conversation,
+      latestSnapshot,
+      snapshotApplied,
+      interrupted: latestSnapshot?.interrupted ?? false,
+      lastDevice,
+      logEntryCount: entries.length
+    };
+  }
+  emptyResult() {
+    return {
+      conversation: [],
+      latestSnapshot: null,
+      snapshotApplied: false,
+      interrupted: false,
+      logEntryCount: 0
+    };
+  }
+  findLatestTreeSnapshot(entries) {
+    const sdkPrefixedMethod = `_${POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT}`;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const entry = entries[i];
+      const method = entry.notification?.method;
+      if (method === sdkPrefixedMethod || method === POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT) {
+        const params = entry.notification.params;
+        if (params?.treeHash) {
+          return params;
+        }
+      }
+    }
+    return null;
+  }
+  findLastDeviceInfo(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const entry = entries[i];
+      const params = entry.notification?.params;
+      if (params?.device) {
+        return params.device;
+      }
+    }
+    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 = [];
+            }
+            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;
+                }
+              }
+            }
+            break;
+          }
+          case "tool_result": {
+            const meta = update._meta?.claudeCode;
+            if (meta) {
+              const toolCallId = meta.toolCallId;
+              const toolResponse = meta.toolResponse;
+              if (toolCallId) {
+                const toolCall = currentToolCalls.find(
+                  (tc) => tc.toolCallId === toolCallId
+                );
+                if (toolCall && toolResponse !== void 0) {
+                  toolCall.result = toolResponse;
+                }
+              }
+            }
+            break;
+          }
+        }
+      }
+    }
+    if (currentAssistantContent.length > 0 || currentToolCalls.length > 0) {
+      turns.push({
+        role: "assistant",
+        content: currentAssistantContent,
+        toolCalls: currentToolCalls.length > 0 ? currentToolCalls : void 0
+      });
+    }
+    return turns;
+  }
+};
+
+// src/resume.ts
+async function resumeFromLog(config) {
+  const logger = config.logger || new Logger({ debug: false, prefix: "[Resume]" });
+  logger.info("Resuming from log", {
+    taskId: config.taskId,
+    runId: config.runId
+  });
+  const saga = new ResumeSaga(logger);
+  const result = await saga.run({
+    taskId: config.taskId,
+    runId: config.runId,
+    repositoryPath: config.repositoryPath,
+    apiClient: config.apiClient,
+    logger
+  });
+  if (!result.success) {
+    logger.error("Failed to resume from log", {
+      error: result.error,
+      failedStep: result.failedStep
+    });
+    throw new Error(
+      `Failed to resume at step '${result.failedStep}': ${result.error}`
+    );
+  }
+  return {
+    conversation: result.data.conversation,
+    latestSnapshot: result.data.latestSnapshot,
+    snapshotApplied: result.data.snapshotApplied,
+    interrupted: result.data.interrupted,
+    lastDevice: result.data.lastDevice,
+    logEntryCount: result.data.logEntryCount
+  };
+}
+
+// src/session-log-writer.ts
+import fs8 from "fs";
+import fsp from "fs/promises";
+import path10 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();
+  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 sessionIds = [...this.sessions.keys()];
+    const flushPromises = [];
+    for (const sessionId of sessionIds) {
+      flushPromises.push(this.flush(sessionId));
+    }
+    await Promise.all(flushPromises);
+  }
+  register(sessionId, context) {
+    if (this.sessions.has(sessionId)) {
+      return;
+    }
+    this.logger.info("Session registered", {
+      taskId: context.taskId,
+      runId: context.runId
+    });
+    this.sessions.set(sessionId, { context });
+    this.lastFlushAttemptTime.set(sessionId, Date.now());
+    if (this.localCachePath) {
+      const sessionDir = path10.join(
+        this.localCachePath,
+        "sessions",
+        context.runId
+      );
+      try {
+        fs8.mkdirSync(sessionDir, { recursive: true });
+      } catch (error) {
+        this.logger.warn("Failed to create local cache directory", {
+          sessionDir,
+          error
+        });
+      }
+    }
+  }
+  isRegistered(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  appendRawLine(sessionId, line) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      this.logger.warn("appendRawLine called for unregistered session", {
+        sessionId
+      });
+      return;
+    }
+    try {
+      const message = JSON.parse(line);
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      if (this.isAgentMessageChunk(message)) {
+        const text2 = this.extractChunkText(message);
+        if (text2) {
+          if (!session.chunkBuffer) {
+            session.chunkBuffer = { text: text2, firstTimestamp: timestamp };
+          } else {
+            session.chunkBuffer.text += text2;
+          }
+        }
+        return;
+      }
+      this.emitCoalescedMessage(sessionId, session);
+      const nonChunkAgentText = this.extractAgentMessageText(message);
+      if (nonChunkAgentText) {
+        session.lastAgentMessage = 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) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      this.logger.warn("flush: no session found", { sessionId });
+      return;
+    }
+    this.emitCoalescedMessage(sessionId, session);
+    const pending = this.pendingEntries.get(sessionId);
+    if (!this.posthogAPI || !pending?.length) {
+      return;
+    }
+    this.pendingEntries.delete(sessionId);
+    const timeout = this.flushTimeouts.get(sessionId);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.flushTimeouts.delete(sessionId);
+    }
+    this.lastFlushAttemptTime.set(sessionId, Date.now());
+    try {
+      await this.posthogAPI.appendTaskRunLog(
+        session.context.taskId,
+        session.context.runId,
+        pending
+      );
+      this.retryCounts.set(sessionId, 0);
+    } catch (error) {
+      const retryCount = (this.retryCounts.get(sessionId) ?? 0) + 1;
+      this.retryCounts.set(sessionId, retryCount);
+      if (retryCount >= _SessionLogWriter.MAX_FLUSH_RETRIES) {
+        this.logger.error(
+          `Dropping ${pending.length} session log entries after ${retryCount} failed flush attempts`,
+          {
+            taskId: session.context.taskId,
+            runId: session.context.runId,
+            error
+          }
+        );
+        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);
+      }
+    }
+  }
+  isAgentMessageChunk(message) {
+    if (message.method !== "session/update") return false;
+    const params = message.params;
+    const update = params?.update;
+    return update?.sessionUpdate === "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;
+    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);
     }
-    return result.data.snapshot;
   }
-  /**
-   * Download and apply a tree snapshot.
-   * Uses Saga pattern for atomic operation with rollback on failure.
-   */
-  async applyTreeSnapshot(snapshot) {
-    if (!this.apiClient) {
-      throw new Error("Cannot apply snapshot: API client not configured");
+  getLastAgentMessage(sessionId) {
+    return this.sessions.get(sessionId)?.lastAgentMessage;
+  }
+  extractAgentMessageText(message) {
+    if (message.method !== "session/update") {
+      return 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");
+    const params = message.params;
+    const update = params?.update;
+    if (update?.sessionUpdate !== "agent_message") {
+      return null;
     }
-    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}`
+    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;
     }
-    this.lastTreeHash = result.data.treeHash;
+    const timeout = setTimeout(() => this.flush(sessionId), delay3);
+    this.flushTimeouts.set(sessionId, timeout);
   }
-  /**
-   * Get the last captured tree hash.
-   */
-  getLastTreeHash() {
-    return this.lastTreeHash;
+  writeToLocalCache(sessionId, entry) {
+    if (!this.localCachePath) return;
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    const logPath = path10.join(
+      this.localCachePath,
+      "sessions",
+      session.context.runId,
+      "logs.ndjson"
+    );
+    try {
+      fs8.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
+      });
+    }
   }
-  /**
-   * Set the last tree hash (used when resuming).
-   */
-  setLastTreeHash(hash) {
-    this.lastTreeHash = hash;
+  static async cleanupOldSessions(localCachePath) {
+    const sessionsDir = path10.join(localCachePath, "sessions");
+    let deleted = 0;
+    try {
+      const entries = await fsp.readdir(sessionsDir);
+      const now = Date.now();
+      for (const entry of entries) {
+        const entryPath = path10.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;
   }
 };
 
@@ -11104,7 +11433,7 @@ function createTappedWritableStream2(underlying, onMessage, logger) {
     }
   });
 }
-var AgentServer = class {
+var AgentServer = class _AgentServer {
   config;
   logger;
   server = null;
@@ -11113,6 +11442,7 @@ var AgentServer = class {
   posthogAPI;
   questionRelayedToSlack = false;
   detectedPrUrl = null;
+  resumeState = null;
   emitConsoleLog = (level, _scope, message, data) => {
     if (!this.session) return;
     const formatted = data !== void 0 ? `${message} ${JSON.stringify(data)}` : message;
@@ -11295,6 +11625,32 @@ var AgentServer = class {
   async autoInitializeSession() {
     const { taskId, runId, mode, projectId } = this.config;
     this.logger.info("Auto-initializing session", { taskId, runId, mode });
+    const resumeRunId = process.env.POSTHOG_RESUME_RUN_ID;
+    if (resumeRunId) {
+      this.logger.info("Resuming from previous run", {
+        resumeRunId,
+        currentRunId: runId
+      });
+      try {
+        this.resumeState = await resumeFromLog({
+          taskId,
+          runId: resumeRunId,
+          repositoryPath: this.config.repositoryPath,
+          apiClient: this.posthogAPI,
+          logger: new Logger({ debug: true, prefix: "[Resume]" })
+        });
+        this.logger.info("Resume state loaded", {
+          conversationTurns: this.resumeState.conversation.length,
+          snapshotApplied: this.resumeState.snapshotApplied,
+          logEntries: this.resumeState.logEntryCount
+        });
+      } catch (error) {
+        this.logger.warn("Failed to load resume state, starting fresh", {
+          error
+        });
+        this.resumeState = null;
+      }
+    }
     const payload = {
       task_id: taskId,
       run_id: runId,
@@ -11359,6 +11715,7 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
             }
           }
         });
+        this.broadcastTurnComplete(result.stopReason);
         return { stopReason: result.stopReason };
       }
       case POSTHOG_NOTIFICATIONS.CANCEL:
@@ -11394,18 +11751,19 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
       name: process.env.HOSTNAME || "cloud-sandbox"
     };
     this.configureEnvironment();
-    const treeTracker = this.config.repositoryPath ? new TreeTracker({
-      repositoryPath: this.config.repositoryPath,
-      taskId: payload.task_id,
-      runId: payload.run_id,
-      logger: new Logger({ debug: true, prefix: "[TreeTracker]" })
-    }) : null;
     const posthogAPI = new PostHogAPIClient({
       apiUrl: this.config.apiUrl,
       projectId: this.config.projectId,
       getApiKey: () => this.config.apiKey,
       userAgent: `posthog/cloud.hog.dev; version: ${this.config.version ?? package_default.version}`
     });
+    const treeTracker = this.config.repositoryPath ? new TreeTracker({
+      repositoryPath: this.config.repositoryPath,
+      taskId: payload.task_id,
+      runId: payload.run_id,
+      apiClient: posthogAPI,
+      logger: new Logger({ debug: true, prefix: "[TreeTracker]" })
+    }) : null;
     const logWriter = new SessionLogWriter({
       posthogAPI,
       logger: new Logger({ debug: true, prefix: "[SessionLogWriter]" })
@@ -11500,26 +11858,55 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
   }
   async sendInitialTaskMessage(payload, prefetchedRun) {
     if (!this.session) return;
-    try {
-      const task = await this.posthogAPI.getTask(payload.task_id);
-      let taskRun = prefetchedRun ?? null;
-      if (!taskRun) {
+    let taskRun = prefetchedRun ?? null;
+    if (!taskRun) {
+      try {
+        taskRun = await this.posthogAPI.getTaskRun(
+          payload.task_id,
+          payload.run_id
+        );
+      } catch (error) {
+        this.logger.warn("Failed to fetch task run", {
+          taskId: payload.task_id,
+          runId: payload.run_id,
+          error
+        });
+      }
+    }
+    if (!this.resumeState) {
+      const resumeRunId = this.getResumeRunId(taskRun);
+      if (resumeRunId) {
+        this.logger.info("Resuming from previous run (via TaskRun state)", {
+          resumeRunId,
+          currentRunId: payload.run_id
+        });
         try {
-          taskRun = await this.posthogAPI.getTaskRun(
-            payload.task_id,
-            payload.run_id
-          );
+          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.info("Resume state loaded (via TaskRun state)", {
+            conversationTurns: this.resumeState.conversation.length,
+            snapshotApplied: this.resumeState.snapshotApplied,
+            logEntries: this.resumeState.logEntryCount
+          });
         } catch (error) {
-          this.logger.warn(
-            "Failed to fetch task run for initial prompt override",
-            {
-              taskId: payload.task_id,
-              runId: payload.run_id,
-              error
-            }
-          );
+          this.logger.warn("Failed to load resume state, starting fresh", {
+            error
+          });
+          this.resumeState = null;
         }
       }
+    }
+    if (this.resumeState && this.resumeState.conversation.length > 0) {
+      await this.sendResumeMessage(payload, taskRun);
+      return;
+    }
+    try {
+      const task = await this.posthogAPI.getTask(payload.task_id);
       const initialPromptOverride = taskRun ? this.getInitialPromptOverride(taskRun) : null;
       const initialPrompt = initialPromptOverride ?? task.description;
       if (!initialPrompt) {
@@ -11538,6 +11925,7 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
       this.logger.info("Initial task message completed", {
         stopReason: result.stopReason
       });
+      this.broadcastTurnComplete(result.stopReason);
       if (result.stopReason === "end_turn") {
         await this.relayAgentResponse(payload);
       }
@@ -11549,6 +11937,94 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
       await this.signalTaskComplete(payload, "error");
     }
   }
+  async sendResumeMessage(payload, taskRun) {
+    if (!this.session || !this.resumeState) return;
+    try {
+      const conversationSummary = this.formatConversationForResume(
+        this.resumeState.conversation
+      );
+      const pendingUserMessage = this.getPendingUserMessage(taskRun);
+      const sandboxContext = this.resumeState.snapshotApplied ? `The sandbox environment (all files, packages, and code changes) has been fully restored from a snapshot.` : `The sandbox could not be restored from a snapshot (it may have expired). You are starting with a fresh environment but have the full conversation history below.`;
+      let resumePrompt;
+      if (pendingUserMessage) {
+        resumePrompt = `You are resuming a previous conversation. ${sandboxContext}
+
+Here is the conversation history from the previous session:
+
+${conversationSummary}
+
+The user has sent a new message:
+
+${pendingUserMessage}
+
+Respond to the user's new message above. You have full context from the previous session.`;
+      } else {
+        resumePrompt = `You are resuming a previous conversation. ${sandboxContext}
+
+Here is the conversation history from the previous session:
+
+${conversationSummary}
+
+Continue from where you left off. The user is waiting for your response.`;
+      }
+      this.logger.info("Sending resume message", {
+        taskId: payload.task_id,
+        conversationTurns: this.resumeState.conversation.length,
+        promptLength: resumePrompt.length,
+        hasPendingUserMessage: !!pendingUserMessage,
+        snapshotApplied: this.resumeState.snapshotApplied
+      });
+      this.resumeState = null;
+      const result = await this.session.clientConnection.prompt({
+        sessionId: this.session.acpSessionId,
+        prompt: [{ type: "text", text: resumePrompt }]
+      });
+      this.logger.info("Resume message completed", {
+        stopReason: result.stopReason
+      });
+      this.broadcastTurnComplete(result.stopReason);
+    } catch (error) {
+      this.logger.error("Failed to send resume message", error);
+      if (this.session) {
+        await this.session.logWriter.flushAll();
+      }
+      await this.signalTaskComplete(payload, "error");
+    }
+  }
+  static RESUME_HISTORY_TOKEN_BUDGET = 5e4;
+  static TOOL_RESULT_MAX_CHARS = 2e3;
+  formatConversationForResume(conversation) {
+    const selected = selectRecentTurns(
+      conversation,
+      _AgentServer.RESUME_HISTORY_TOKEN_BUDGET
+    );
+    const parts = [];
+    if (selected.length < conversation.length) {
+      parts.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) {
+        parts.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 > _AgentServer.TOOL_RESULT_MAX_CHARS ? ` \u2192 ${raw.substring(0, _AgentServer.TOOL_RESULT_MAX_CHARS)}...(truncated)` : ` \u2192 ${raw}`;
+          }
+          return `  - ${tc.toolName}${resultStr}`;
+        }).join("\n");
+        parts.push(`**${role} (tools)**:
+${toolSummary}`);
+      }
+    }
+    return parts.join("\n\n");
+  }
   getInitialPromptOverride(taskRun) {
     const state = taskRun.state;
     const override = state?.initial_prompt_override;
@@ -11558,6 +12034,24 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
     const trimmed2 = override.trim();
     return trimmed2.length > 0 ? trimmed2 : null;
   }
+  getPendingUserMessage(taskRun) {
+    if (!taskRun) return null;
+    const state = taskRun.state;
+    const message = state?.pending_user_message;
+    if (typeof message !== "string") {
+      return null;
+    }
+    const trimmed2 = message.trim();
+    return trimmed2.length > 0 ? trimmed2 : null;
+  }
+  getResumeRunId(taskRun) {
+    const envRunId = process.env.POSTHOG_RESUME_RUN_ID;
+    if (envRunId) return envRunId;
+    if (!taskRun) return null;
+    const state = taskRun.state;
+    const stateRunId = state?.resume_from_run_id;
+    return typeof stateRunId === "string" && stateRunId.trim().length > 0 ? stateRunId.trim() : null;
+  }
   buildCloudSystemPrompt(prUrl) {
     if (prUrl) {
       return `
@@ -11882,20 +12376,30 @@ Important:
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           notification
         });
-        const { archiveUrl: _, ...paramsWithoutArchive } = snapshotWithDevice;
-        const logNotification = {
-          ...notification,
-          params: paramsWithoutArchive
-        };
         this.session.logWriter.appendRawLine(
           this.session.payload.run_id,
-          JSON.stringify(logNotification)
+          JSON.stringify(notification)
         );
       }
     } catch (error) {
       this.logger.error("Failed to capture tree state", error);
     }
   }
+  broadcastTurnComplete(stopReason) {
+    if (!this.session) return;
+    this.broadcastEvent({
+      type: "notification",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      notification: {
+        jsonrpc: "2.0",
+        method: POSTHOG_NOTIFICATIONS.TURN_COMPLETE,
+        params: {
+          sessionId: this.session.acpSessionId,
+          stopReason
+        }
+      }
+    });
+  }
   broadcastEvent(event) {
     if (this.session?.sseController) {
       this.sendSseEvent(this.session.sseController, event);