@posthog/agent 2.0.0 → 2.0.1

package/dist/server/agent-server.js

@@ -0,0 +1,4451 @@
+// src/server/agent-server.ts
+import {
+  ClientSideConnection,
+  ndJsonStream as ndJsonStream2,
+  PROTOCOL_VERSION
+} from "@agentclientprotocol/sdk";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+
+// src/acp-extensions.ts
+var POSTHOG_NOTIFICATIONS = {
+  /** Git branch was created for a task */
+  BRANCH_CREATED: "_posthog/branch_created",
+  /** Task run has started execution */
+  RUN_STARTED: "_posthog/run_started",
+  /** Task has completed (success or failure) */
+  TASK_COMPLETE: "_posthog/task_complete",
+  /** Error occurred during task execution */
+  ERROR: "_posthog/error",
+  /** Console/log output from the agent */
+  CONSOLE: "_posthog/console",
+  /** Maps taskRunId to agent's sessionId and adapter type (for resumption) */
+  SDK_SESSION: "_posthog/sdk_session",
+  /** Tree state snapshot captured (git tree hash + file archive) */
+  TREE_SNAPSHOT: "_posthog/tree_snapshot",
+  /** Agent mode changed (interactive/background) */
+  MODE_CHANGE: "_posthog/mode_change",
+  /** Request to resume a session from previous state */
+  SESSION_RESUME: "_posthog/session/resume",
+  /** User message sent from client to agent */
+  USER_MESSAGE: "_posthog/user_message",
+  /** Request to cancel current operation */
+  CANCEL: "_posthog/cancel",
+  /** Request to close the session */
+  CLOSE: "_posthog/close",
+  /** Agent status update (thinking, working, etc.) */
+  STATUS: "_posthog/status",
+  /** Task-level notification (progress, milestones) */
+  TASK_NOTIFICATION: "_posthog/task_notification",
+  /** Marks a boundary for log compaction */
+  COMPACT_BOUNDARY: "_posthog/compact_boundary"
+};
+
+// src/adapters/acp-connection.ts
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+
+// src/utils/logger.ts
+var Logger = class _Logger {
+  debugEnabled;
+  prefix;
+  scope;
+  onLog;
+  constructor(config = {}) {
+    this.debugEnabled = config.debug ?? false;
+    this.prefix = config.prefix ?? "[PostHog Agent]";
+    this.scope = config.scope ?? "agent";
+    this.onLog = config.onLog;
+  }
+  formatMessage(level, message, data) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const base = `${timestamp} ${this.prefix} [${level}] ${message}`;
+    if (data !== void 0) {
+      return `${base} ${JSON.stringify(data, null, 2)}`;
+    }
+    return base;
+  }
+  emitLog(level, message, data) {
+    if (this.onLog) {
+      this.onLog(level, this.scope, message, data);
+      return;
+    }
+    const shouldLog = this.debugEnabled || level === "error";
+    if (shouldLog) {
+      console[level](this.formatMessage(level.toLowerCase(), message, data));
+    }
+  }
+  error(message, error) {
+    const data = error instanceof Error ? { message: error.message, stack: error.stack } : error;
+    this.emitLog("error", message, data);
+  }
+  warn(message, data) {
+    this.emitLog("warn", message, data);
+  }
+  info(message, data) {
+    this.emitLog("info", message, data);
+  }
+  debug(message, data) {
+    this.emitLog("debug", message, data);
+  }
+  child(childPrefix) {
+    return new _Logger({
+      debug: this.debugEnabled,
+      prefix: `${this.prefix} [${childPrefix}]`,
+      scope: `${this.scope}:${childPrefix}`,
+      onLog: this.onLog
+    });
+  }
+};
+
+// src/utils/streams.ts
+import { ReadableStream as ReadableStream2, WritableStream as WritableStream2 } from "stream/web";
+var Pushable = class {
+  queue = [];
+  resolvers = [];
+  done = false;
+  push(item) {
+    const resolve3 = this.resolvers.shift();
+    if (resolve3) {
+      resolve3({ value: item, done: false });
+    } else {
+      this.queue.push(item);
+    }
+  }
+  end() {
+    this.done = true;
+    for (const resolve3 of this.resolvers) {
+      resolve3({ value: void 0, done: true });
+    }
+    this.resolvers = [];
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.queue.length > 0) {
+          const value = this.queue.shift();
+          return Promise.resolve({ value, done: false });
+        }
+        if (this.done) {
+          return Promise.resolve({
+            value: void 0,
+            done: true
+          });
+        }
+        return new Promise((resolve3) => {
+          this.resolvers.push(resolve3);
+        });
+      }
+    };
+  }
+};
+function pushableToReadableStream(pushable) {
+  const iterator = pushable[Symbol.asyncIterator]();
+  return new ReadableStream2({
+    async pull(controller) {
+      const { value, done } = await iterator.next();
+      if (done) {
+        controller.close();
+      } else {
+        controller.enqueue(value);
+      }
+    }
+  });
+}
+function createBidirectionalStreams() {
+  const clientToAgentPushable = new Pushable();
+  const agentToClientPushable = new Pushable();
+  const clientToAgentReadable = pushableToReadableStream(clientToAgentPushable);
+  const agentToClientReadable = pushableToReadableStream(agentToClientPushable);
+  const clientToAgentWritable = new WritableStream2({
+    write(chunk) {
+      clientToAgentPushable.push(chunk);
+    },
+    close() {
+      clientToAgentPushable.end();
+    }
+  });
+  const agentToClientWritable = new WritableStream2({
+    write(chunk) {
+      agentToClientPushable.push(chunk);
+    },
+    close() {
+      agentToClientPushable.end();
+    }
+  });
+  return {
+    client: {
+      readable: agentToClientReadable,
+      writable: clientToAgentWritable
+    },
+    agent: {
+      readable: clientToAgentReadable,
+      writable: agentToClientWritable
+    }
+  };
+}
+function createTappedWritableStream(underlying, options) {
+  const { onMessage, logger } = options;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let _messageCount = 0;
+  return new WritableStream2({
+    async write(chunk) {
+      buffer += decoder.decode(chunk, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        _messageCount++;
+        onMessage(line);
+      }
+      try {
+        const writer = underlying.getWriter();
+        await writer.write(chunk);
+        writer.releaseLock();
+      } catch (err) {
+        logger?.error("ACP write error", err);
+      }
+    },
+    async close() {
+      try {
+        const writer = underlying.getWriter();
+        await writer.close();
+        writer.releaseLock();
+      } catch {
+      }
+    },
+    async abort(reason) {
+      logger?.warn("Tapped stream aborted", { reason });
+      try {
+        const writer = underlying.getWriter();
+        await writer.abort(reason);
+        writer.releaseLock();
+      } catch {
+      }
+    }
+  });
+}
+function nodeReadableToWebReadable(nodeStream) {
+  return new ReadableStream2({
+    start(controller) {
+      nodeStream.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk));
+      });
+      nodeStream.on("end", () => {
+        controller.close();
+      });
+      nodeStream.on("error", (err) => {
+        controller.error(err);
+      });
+    },
+    cancel() {
+      nodeStream.destroy();
+    }
+  });
+}
+function nodeWritableToWebWritable(nodeStream) {
+  return new WritableStream2({
+    write(chunk) {
+      return new Promise((resolve3, reject) => {
+        const ok = nodeStream.write(Buffer.from(chunk), (err) => {
+          if (err) reject(err);
+        });
+        if (ok) {
+          resolve3();
+        } else {
+          nodeStream.once("drain", resolve3);
+        }
+      });
+    },
+    close() {
+      return new Promise((resolve3) => {
+        nodeStream.end(resolve3);
+      });
+    },
+    abort(reason) {
+      nodeStream.destroy(
+        reason instanceof Error ? reason : new Error(String(reason))
+      );
+    }
+  });
+}
+
+// src/adapters/claude/claude-agent.ts
+import * as fs2 from "fs";
+import * as os3 from "os";
+import * as path3 from "path";
+import {
+  RequestError as RequestError2
+} from "@agentclientprotocol/sdk";
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+import { v7 as uuidv7 } from "uuid";
+
+// package.json
+var package_default = {
+  name: "@posthog/agent",
+  version: "2.0.1",
+  repository: "https://github.com/PostHog/twig",
+  description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./agent": {
+      types: "./dist/agent.d.ts",
+      import: "./dist/agent.js"
+    },
+    "./gateway-models": {
+      types: "./dist/gateway-models.d.ts",
+      import: "./dist/gateway-models.js"
+    },
+    "./posthog-api": {
+      types: "./dist/posthog-api.d.ts",
+      import: "./dist/posthog-api.js"
+    },
+    "./types": {
+      types: "./dist/types.d.ts",
+      import: "./dist/types.js"
+    },
+    "./adapters/claude/questions/utils": {
+      types: "./dist/adapters/claude/questions/utils.d.ts",
+      import: "./dist/adapters/claude/questions/utils.js"
+    },
+    "./adapters/claude/permissions/permission-options": {
+      types: "./dist/adapters/claude/permissions/permission-options.d.ts",
+      import: "./dist/adapters/claude/permissions/permission-options.js"
+    },
+    "./adapters/claude/tools": {
+      types: "./dist/adapters/claude/tools.d.ts",
+      import: "./dist/adapters/claude/tools.js"
+    },
+    "./adapters/claude/conversion/tool-use-to-acp": {
+      types: "./dist/adapters/claude/conversion/tool-use-to-acp.d.ts",
+      import: "./dist/adapters/claude/conversion/tool-use-to-acp.js"
+    },
+    "./server": {
+      types: "./dist/server/agent-server.d.ts",
+      import: "./dist/server/agent-server.js"
+    }
+  },
+  bin: {
+    "agent-server": "./dist/server/bin.js"
+  },
+  type: "module",
+  keywords: [
+    "posthog",
+    "claude",
+    "agent",
+    "ai",
+    "git",
+    "typescript"
+  ],
+  author: "PostHog",
+  license: "SEE LICENSE IN LICENSE",
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest run",
+    "test:watch": "vitest",
+    typecheck: "pnpm exec tsc --noEmit",
+    prepublishOnly: "pnpm run build"
+  },
+  engines: {
+    node: ">=20.0.0"
+  },
+  devDependencies: {
+    "@changesets/cli": "^2.27.8",
+    "@types/bun": "latest",
+    "@types/tar": "^6.1.13",
+    minimatch: "^10.0.3",
+    msw: "^2.12.7",
+    tsup: "^8.5.1",
+    tsx: "^4.20.6",
+    typescript: "^5.5.0",
+    vitest: "^2.1.8"
+  },
+  dependencies: {
+    "@opentelemetry/api-logs": "^0.208.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.208.0",
+    "@opentelemetry/resources": "^2.0.0",
+    "@opentelemetry/sdk-logs": "^0.208.0",
+    "@opentelemetry/semantic-conventions": "^1.28.0",
+    "@agentclientprotocol/sdk": "^0.14.0",
+    "@anthropic-ai/claude-agent-sdk": "0.2.12",
+    "@anthropic-ai/sdk": "^0.71.0",
+    "@hono/node-server": "^1.19.9",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "@posthog/shared": "workspace:*",
+    "@twig/git": "workspace:*",
+    "@types/jsonwebtoken": "^9.0.10",
+    commander: "^14.0.2",
+    diff: "^8.0.2",
+    dotenv: "^17.2.3",
+    hono: "^4.11.7",
+    jsonwebtoken: "^9.0.2",
+    tar: "^7.5.0",
+    uuid: "13.0.0",
+    "yoga-wasm-web": "^0.3.3",
+    zod: "^3.24.1"
+  },
+  files: [
+    "dist/**/*",
+    "src/**/*",
+    "README.md",
+    "CLAUDE.md"
+  ],
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/utils/common.ts
+var IS_ROOT = typeof process !== "undefined" && (process.geteuid?.() ?? process.getuid?.()) === 0;
+function unreachable(value, logger) {
+  let valueAsString;
+  try {
+    valueAsString = JSON.stringify(value);
+  } catch {
+    valueAsString = value;
+  }
+  logger.error(`Unexpected case: ${valueAsString}`);
+}
+
+// src/gateway-models.ts
+var DEFAULT_GATEWAY_MODEL = "claude-opus-4-6";
+var BLOCKED_MODELS = /* @__PURE__ */ new Set(["gpt-5-mini", "openai/gpt-5-mini"]);
+async function fetchGatewayModels(options) {
+  const gatewayUrl = options?.gatewayUrl ?? process.env.ANTHROPIC_BASE_URL;
+  if (!gatewayUrl) {
+    return [];
+  }
+  const modelsUrl = `${gatewayUrl}/v1/models`;
+  try {
+    const response = await fetch(modelsUrl);
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    const models = data.data ?? [];
+    return models.filter((m) => !BLOCKED_MODELS.has(m.id));
+  } catch {
+    return [];
+  }
+}
+function isAnthropicModel(model) {
+  if (model.owned_by) {
+    return model.owned_by === "anthropic";
+  }
+  return model.id.startsWith("claude-") || model.id.startsWith("anthropic/");
+}
+var PROVIDER_PREFIXES = ["anthropic/", "openai/", "google-vertex/"];
+function formatGatewayModelName(model) {
+  let cleanId = model.id;
+  for (const prefix of PROVIDER_PREFIXES) {
+    if (cleanId.startsWith(prefix)) {
+      cleanId = cleanId.slice(prefix.length);
+      break;
+    }
+  }
+  cleanId = cleanId.replace(/(\d)-(\d)/g, "$1.$2");
+  const words = cleanId.split(/[-_]/).map((word) => {
+    if (word.match(/^[0-9.]+$/)) return word;
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  });
+  return words.join(" ");
+}
+
+// src/adapters/base-acp-agent.ts
+var BaseAcpAgent = class {
+  session;
+  sessionId;
+  client;
+  logger;
+  fileContentCache = {};
+  constructor(client) {
+    this.client = client;
+    this.logger = new Logger({ debug: true, prefix: "[BaseAcpAgent]" });
+  }
+  async cancel(params) {
+    if (this.sessionId !== params.sessionId) {
+      throw new Error("Session not found");
+    }
+    this.session.cancelled = true;
+    const meta = params._meta;
+    if (meta?.interruptReason) {
+      this.session.interruptReason = meta.interruptReason;
+    }
+    await this.interruptSession();
+  }
+  async closeSession() {
+    try {
+      this.session.abortController.abort();
+      await this.cancel({ sessionId: this.sessionId });
+      this.logger.info("Closed session", { sessionId: this.sessionId });
+    } catch (err) {
+      this.logger.warn("Failed to close session", {
+        sessionId: this.sessionId,
+        error: err
+      });
+    }
+  }
+  hasSession(sessionId) {
+    return this.sessionId === sessionId;
+  }
+  appendNotification(sessionId, notification) {
+    if (this.sessionId === sessionId) {
+      this.session.notificationHistory.push(notification);
+    }
+  }
+  async readTextFile(params) {
+    const response = await this.client.readTextFile(params);
+    if (!params.limit && !params.line) {
+      this.fileContentCache[params.path] = response.content;
+    }
+    return response;
+  }
+  async writeTextFile(params) {
+    const response = await this.client.writeTextFile(params);
+    this.fileContentCache[params.path] = params.content;
+    return response;
+  }
+  async authenticate(_params) {
+    throw new Error("Method not implemented.");
+  }
+  async getModelConfigOptions(currentModelOverride) {
+    const gatewayModels = await fetchGatewayModels();
+    const options = gatewayModels.filter((model) => isAnthropicModel(model)).map((model) => ({
+      value: model.id,
+      name: formatGatewayModelName(model),
+      description: `Context: ${model.context_window.toLocaleString()} tokens`
+    }));
+    const isAnthropicModelId = (modelId) => modelId.startsWith("claude-") || modelId.startsWith("anthropic/");
+    let currentModelId = currentModelOverride ?? DEFAULT_GATEWAY_MODEL;
+    if (!options.some((opt) => opt.value === currentModelId)) {
+      if (!isAnthropicModelId(currentModelId)) {
+        currentModelId = DEFAULT_GATEWAY_MODEL;
+      }
+    }
+    if (!options.some((opt) => opt.value === currentModelId)) {
+      options.unshift({
+        value: currentModelId,
+        name: currentModelId,
+        description: "Custom model"
+      });
+    }
+    return { currentModelId, options };
+  }
+};
+
+// src/adapters/claude/conversion/acp-to-sdk.ts
+function sdkText(value) {
+  return { type: "text", text: value };
+}
+function formatUriAsLink(uri) {
+  try {
+    if (uri.startsWith("file://")) {
+      const filePath = uri.slice(7);
+      const name = filePath.split("/").pop() || filePath;
+      return `[@${name}](${uri})`;
+    }
+    if (uri.startsWith("zed://")) {
+      const parts = uri.split("/");
+      const name = parts[parts.length - 1] || uri;
+      return `[@${name}](${uri})`;
+    }
+    return uri;
+  } catch {
+    return uri;
+  }
+}
+function transformMcpCommand(text2) {
+  const mcpMatch = text2.match(/^\/mcp:([^:\s]+):(\S+)(\s+.*)?$/);
+  if (mcpMatch) {
+    const [, server, command, args] = mcpMatch;
+    return `/${server}:${command} (MCP)${args || ""}`;
+  }
+  return text2;
+}
+function processPromptChunk(chunk, content, context) {
+  switch (chunk.type) {
+    case "text":
+      content.push(sdkText(transformMcpCommand(chunk.text)));
+      break;
+    case "resource_link":
+      content.push(sdkText(formatUriAsLink(chunk.uri)));
+      break;
+    case "resource":
+      if ("text" in chunk.resource) {
+        content.push(sdkText(formatUriAsLink(chunk.resource.uri)));
+        context.push(
+          sdkText(
+            `
+<context ref="${chunk.resource.uri}">
+${chunk.resource.text}
+</context>`
+          )
+        );
+      }
+      break;
+    case "image":
+      if (chunk.data) {
+        content.push({
+          type: "image",
+          source: {
+            type: "base64",
+            data: chunk.data,
+            media_type: chunk.mimeType
+          }
+        });
+      } else if (chunk.uri?.startsWith("http")) {
+        content.push({
+          type: "image",
+          source: { type: "url", url: chunk.uri }
+        });
+      }
+      break;
+    default:
+      break;
+  }
+}
+function promptToClaude(prompt) {
+  const content = [];
+  const context = [];
+  for (const chunk of prompt.prompt) {
+    processPromptChunk(chunk, content, context);
+  }
+  content.push(...context);
+  return {
+    type: "user",
+    message: { role: "user", content },
+    session_id: prompt.sessionId,
+    parent_tool_use_id: null
+  };
+}
+
+// src/adapters/claude/conversion/sdk-to-acp.ts
+import { RequestError } from "@agentclientprotocol/sdk";
+
+// src/utils/acp-content.ts
+function text(value) {
+  return { type: "text", text: value };
+}
+function image(data, mimeType, uri) {
+  return { type: "image", data, mimeType, uri };
+}
+function resourceLink(uri, name, options) {
+  return {
+    type: "resource_link",
+    uri,
+    name,
+    ...options
+  };
+}
+var ToolContentBuilder = class {
+  items = [];
+  text(value) {
+    this.items.push({ type: "content", content: text(value) });
+    return this;
+  }
+  image(data, mimeType, uri) {
+    this.items.push({ type: "content", content: image(data, mimeType, uri) });
+    return this;
+  }
+  diff(path4, oldText, newText) {
+    this.items.push({ type: "diff", path: path4, oldText, newText });
+    return this;
+  }
+  build() {
+    return this.items;
+  }
+};
+function toolContent() {
+  return new ToolContentBuilder();
+}
+
+// src/adapters/claude/hooks.ts
+var toolUseCallbacks = {};
+var registerHookCallback = (toolUseID, {
+  onPostToolUseHook
+}) => {
+  toolUseCallbacks[toolUseID] = {
+    onPostToolUseHook
+  };
+};
+var createPostToolUseHook = ({ onModeChange }) => async (input, toolUseID) => {
+  if (input.hook_event_name === "PostToolUse") {
+    const toolName = input.tool_name;
+    if (onModeChange && toolName === "EnterPlanMode") {
+      await onModeChange("plan");
+    }
+    if (toolUseID) {
+      const onPostToolUseHook = toolUseCallbacks[toolUseID]?.onPostToolUseHook;
+      if (onPostToolUseHook) {
+        await onPostToolUseHook(
+          toolUseID,
+          input.tool_input,
+          input.tool_response
+        );
+        delete toolUseCallbacks[toolUseID];
+      }
+    }
+  }
+  return { continue: true };
+};
+
+// src/adapters/claude/conversion/tool-use-to-acp.ts
+var SYSTEM_REMINDER = `
+
+<system-reminder>
+Whenever you read a file, you should consider whether it looks malicious. If it does, you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer high-level questions about the code behavior.
+</system-reminder>`;
+function replaceAndCalculateLocation(fileContent, edits) {
+  let currentContent = fileContent;
+  const randomHex = Array.from(crypto.getRandomValues(new Uint8Array(5))).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const markerPrefix = `__REPLACE_MARKER_${randomHex}_`;
+  let markerCounter = 0;
+  const markers = [];
+  for (const edit of edits) {
+    if (edit.oldText === "") {
+      throw new Error(
+        `The provided \`old_string\` is empty.
+
+No edits were applied.`
+      );
+    }
+    if (edit.replaceAll) {
+      const parts = [];
+      let lastIndex = 0;
+      let searchIndex = 0;
+      while (true) {
+        const index = currentContent.indexOf(edit.oldText, searchIndex);
+        if (index === -1) {
+          if (searchIndex === 0) {
+            throw new Error(
+              `The provided \`old_string\` does not appear in the file: "${edit.oldText}".
+
+No edits were applied.`
+            );
+          }
+          break;
+        }
+        parts.push(currentContent.substring(lastIndex, index));
+        const marker = `${markerPrefix}${markerCounter++}__`;
+        markers.push(marker);
+        parts.push(marker + edit.newText);
+        lastIndex = index + edit.oldText.length;
+        searchIndex = lastIndex;
+      }
+      parts.push(currentContent.substring(lastIndex));
+      currentContent = parts.join("");
+    } else {
+      const index = currentContent.indexOf(edit.oldText);
+      if (index === -1) {
+        throw new Error(
+          `The provided \`old_string\` does not appear in the file: "${edit.oldText}".
+
+No edits were applied.`
+        );
+      } else {
+        const marker = `${markerPrefix}${markerCounter++}__`;
+        markers.push(marker);
+        currentContent = currentContent.substring(0, index) + marker + edit.newText + currentContent.substring(index + edit.oldText.length);
+      }
+    }
+  }
+  const lineNumbers = [];
+  for (const marker of markers) {
+    const index = currentContent.indexOf(marker);
+    if (index !== -1) {
+      const lineNumber = Math.max(
+        0,
+        currentContent.substring(0, index).split(/\r\n|\r|\n/).length - 1
+      );
+      lineNumbers.push(lineNumber);
+    }
+  }
+  let finalContent = currentContent;
+  for (const marker of markers) {
+    finalContent = finalContent.replace(marker, "");
+  }
+  const uniqueLineNumbers = [...new Set(lineNumbers)].sort();
+  return { newContent: finalContent, lineNumbers: uniqueLineNumbers };
+}
+function toolInfoFromToolUse(toolUse, cachedFileContent, logger = new Logger({ debug: false, prefix: "[ClaudeTools]" })) {
+  const name = toolUse.name;
+  const input = toolUse.input;
+  switch (name) {
+    case "Task":
+      return {
+        title: input?.description ? String(input.description) : "Task",
+        kind: "think",
+        content: input?.prompt ? toolContent().text(String(input.prompt)).build() : []
+      };
+    case "NotebookRead":
+      return {
+        title: input?.notebook_path ? `Read Notebook ${String(input.notebook_path)}` : "Read Notebook",
+        kind: "read",
+        content: [],
+        locations: input?.notebook_path ? [{ path: String(input.notebook_path) }] : []
+      };
+    case "NotebookEdit":
+      return {
+        title: input?.notebook_path ? `Edit Notebook ${String(input.notebook_path)}` : "Edit Notebook",
+        kind: "edit",
+        content: input?.new_source ? toolContent().text(String(input.new_source)).build() : [],
+        locations: input?.notebook_path ? [{ path: String(input.notebook_path) }] : []
+      };
+    case "Bash":
+      return {
+        title: input?.description ? String(input.description) : "Execute command",
+        kind: "execute",
+        content: input?.command ? toolContent().text(String(input.command)).build() : []
+      };
+    case "BashOutput":
+      return {
+        title: "Tail Logs",
+        kind: "execute",
+        content: []
+      };
+    case "KillShell":
+      return {
+        title: "Kill Process",
+        kind: "execute",
+        content: []
+      };
+    case "Read": {
+      let limit = "";
+      const inputLimit = input?.limit;
+      const inputOffset = input?.offset ?? 0;
+      if (inputLimit) {
+        limit = ` (${inputOffset + 1} - ${inputOffset + inputLimit})`;
+      } else if (inputOffset) {
+        limit = ` (from line ${inputOffset + 1})`;
+      }
+      return {
+        title: `Read ${input?.file_path ? String(input.file_path) : "File"}${limit}`,
+        kind: "read",
+        locations: input?.file_path ? [
+          {
+            path: String(input.file_path),
+            line: inputOffset
+          }
+        ] : [],
+        content: []
+      };
+    }
+    case "LS":
+      return {
+        title: `List the ${input?.path ? `\`${String(input.path)}\`` : "current"} directory's contents`,
+        kind: "search",
+        content: [],
+        locations: []
+      };
+    case "Edit": {
+      const path4 = input?.file_path ? String(input.file_path) : void 0;
+      let oldText = input?.old_string ? String(input.old_string) : null;
+      let newText = input?.new_string ? String(input.new_string) : "";
+      let affectedLines = [];
+      if (path4 && oldText) {
+        try {
+          const oldContent = cachedFileContent[path4] || "";
+          const newContent = replaceAndCalculateLocation(oldContent, [
+            {
+              oldText,
+              newText,
+              replaceAll: false
+            }
+          ]);
+          oldText = oldContent;
+          newText = newContent.newContent;
+          affectedLines = newContent.lineNumbers;
+        } catch (e) {
+          logger.error("Failed to edit file", e);
+        }
+      }
+      return {
+        title: path4 ? `Edit \`${path4}\`` : "Edit",
+        kind: "edit",
+        content: input && path4 ? [
+          {
+            type: "diff",
+            path: path4,
+            oldText,
+            newText
+          }
+        ] : [],
+        locations: path4 ? affectedLines.length > 0 ? affectedLines.map((line) => ({ line, path: path4 })) : [{ path: path4 }] : []
+      };
+    }
+    case "Write": {
+      let contentResult = [];
+      const filePath = input?.file_path ? String(input.file_path) : void 0;
+      const contentStr = input?.content ? String(input.content) : void 0;
+      if (filePath) {
+        contentResult = toolContent().diff(filePath, null, contentStr ?? "").build();
+      } else if (contentStr) {
+        contentResult = toolContent().text(contentStr).build();
+      }
+      return {
+        title: filePath ? `Write ${filePath}` : "Write",
+        kind: "edit",
+        content: contentResult,
+        locations: filePath ? [{ path: filePath }] : []
+      };
+    }
+    case "Glob": {
+      let label = "Find";
+      const pathStr = input?.path ? String(input.path) : void 0;
+      if (pathStr) {
+        label += ` "${pathStr}"`;
+      }
+      if (input?.pattern) {
+        label += ` "${String(input.pattern)}"`;
+      }
+      return {
+        title: label,
+        kind: "search",
+        content: [],
+        locations: pathStr ? [{ path: pathStr }] : []
+      };
+    }
+    case "Grep": {
+      let label = "grep";
+      if (input?.["-i"]) {
+        label += " -i";
+      }
+      if (input?.["-n"]) {
+        label += " -n";
+      }
+      if (input?.["-A"] !== void 0) {
+        label += ` -A ${input["-A"]}`;
+      }
+      if (input?.["-B"] !== void 0) {
+        label += ` -B ${input["-B"]}`;
+      }
+      if (input?.["-C"] !== void 0) {
+        label += ` -C ${input["-C"]}`;
+      }
+      if (input?.output_mode) {
+        switch (input.output_mode) {
+          case "FilesWithMatches":
+            label += " -l";
+            break;
+          case "Count":
+            label += " -c";
+            break;
+          default:
+            break;
+        }
+      }
+      if (input?.head_limit !== void 0) {
+        label += ` | head -${input.head_limit}`;
+      }
+      if (input?.glob) {
+        label += ` --include="${String(input.glob)}"`;
+      }
+      if (input?.type) {
+        label += ` --type=${String(input.type)}`;
+      }
+      if (input?.multiline) {
+        label += " -P";
+      }
+      label += ` "${input?.pattern ? String(input.pattern) : ""}"`;
+      if (input?.path) {
+        label += ` ${String(input.path)}`;
+      }
+      return {
+        title: label,
+        kind: "search",
+        content: []
+      };
+    }
+    case "WebFetch":
+      return {
+        title: "Fetch",
+        kind: "fetch",
+        content: input?.url ? [
+          {
+            type: "content",
+            content: resourceLink(String(input.url), String(input.url), {
+              description: input?.prompt ? String(input.prompt) : void 0
+            })
+          }
+        ] : []
+      };
+    case "WebSearch": {
+      let label = `"${input?.query ? String(input.query) : ""}"`;
+      const allowedDomains = input?.allowed_domains;
+      const blockedDomains = input?.blocked_domains;
+      if (allowedDomains && allowedDomains.length > 0) {
+        label += ` (allowed: ${allowedDomains.join(", ")})`;
+      }
+      if (blockedDomains && blockedDomains.length > 0) {
+        label += ` (blocked: ${blockedDomains.join(", ")})`;
+      }
+      return {
+        title: label,
+        kind: "fetch",
+        content: []
+      };
+    }
+    case "TodoWrite":
+      return {
+        title: Array.isArray(input?.todos) ? `Update TODOs: ${input.todos.map((todo) => todo.content).join(", ")}` : "Update TODOs",
+        kind: "think",
+        content: []
+      };
+    case "ExitPlanMode":
+      return {
+        title: "Ready to code?",
+        kind: "switch_mode",
+        content: input?.plan ? toolContent().text(String(input.plan)).build() : []
+      };
+    case "AskUserQuestion": {
+      const questions = input?.questions;
+      return {
+        title: questions?.[0]?.question || "Question",
+        kind: "other",
+        content: questions ? toolContent().text(JSON.stringify(questions, null, 2)).build() : []
+      };
+    }
+    case "Other": {
+      let output;
+      try {
+        output = JSON.stringify(input, null, 2);
+      } catch {
+        output = typeof input === "string" ? input : "{}";
+      }
+      return {
+        title: name || "Unknown Tool",
+        kind: "other",
+        content: toolContent().text(`\`\`\`json
+${output}\`\`\``).build()
+      };
+    }
+    default:
+      return {
+        title: name || "Unknown Tool",
+        kind: "other",
+        content: []
+      };
+  }
+}
+function toolUpdateFromToolResult(toolResult, toolUse) {
+  switch (toolUse?.name) {
+    case "Read":
+      if (Array.isArray(toolResult.content) && toolResult.content.length > 0) {
+        return {
+          content: toolResult.content.map((item) => {
+            const itemObj = item;
+            if (itemObj.type === "text") {
+              return {
+                type: "content",
+                content: text(
+                  markdownEscape(
+                    (itemObj.text ?? "").replace(SYSTEM_REMINDER, "")
+                  )
+                )
+              };
+            }
+            return {
+              type: "content",
+              content: item
+            };
+          })
+        };
+      } else if (typeof toolResult.content === "string" && toolResult.content.length > 0) {
+        return {
+          content: toolContent().text(
+            markdownEscape(toolResult.content.replace(SYSTEM_REMINDER, ""))
+          ).build()
+        };
+      }
+      return {};
+    case "Bash": {
+      return toAcpContentUpdate(
+        toolResult.content,
+        "is_error" in toolResult ? toolResult.is_error : false
+      );
+    }
+    case "Edit":
+    case "Write": {
+      if ("is_error" in toolResult && toolResult.is_error && toolResult.content && toolResult.content.length > 0) {
+        return toAcpContentUpdate(toolResult.content, true);
+      }
+      return {};
+    }
+    case "ExitPlanMode": {
+      return { title: "Exited Plan Mode" };
+    }
+    case "AskUserQuestion": {
+      const content = toolResult.content;
+      if (Array.isArray(content) && content.length > 0) {
+        const firstItem = content[0];
+        if (typeof firstItem === "object" && firstItem !== null && "text" in firstItem) {
+          return {
+            title: "Answer received",
+            content: toolContent().text(String(firstItem.text)).build()
+          };
+        }
+      }
+      return { title: "Question answered" };
+    }
+    default: {
+      return toAcpContentUpdate(
+        toolResult.content,
+        "is_error" in toolResult ? toolResult.is_error : false
+      );
+    }
+  }
+}
+function toAcpContentUpdate(content, isError = false) {
+  if (Array.isArray(content) && content.length > 0) {
+    return {
+      content: content.map((item) => {
+        const itemObj = item;
+        if (isError && itemObj.type === "text") {
+          return {
+            type: "content",
+            content: text(`\`\`\`
+${itemObj.text ?? ""}
+\`\`\``)
+          };
+        }
+        return {
+          type: "content",
+          content: item
+        };
+      })
+    };
+  } else if (typeof content === "string" && content.length > 0) {
+    return {
+      content: toolContent().text(isError ? `\`\`\`
+${content}
+\`\`\`` : content).build()
+    };
+  }
+  return {};
+}
+function planEntries(input) {
+  return input.todos.map((input2) => ({
+    content: input2.content,
+    status: input2.status,
+    priority: "medium"
+  }));
+}
+function markdownEscape(text2) {
+  let escapedText = "```";
+  for (const [m] of text2.matchAll(/^```+/gm)) {
+    while (m.length >= escapedText.length) {
+      escapedText += "`";
+    }
+  }
+  return `${escapedText}
+${text2}${text2.endsWith("\n") ? "" : "\n"}${escapedText}`;
+}
+
+// src/adapters/claude/conversion/sdk-to-acp.ts
+function messageUpdateType(role) {
+  return role === "assistant" ? "agent_message_chunk" : "user_message_chunk";
+}
+function toolMeta(toolName, toolResponse) {
+  return toolResponse ? { claudeCode: { toolName, toolResponse } } : { claudeCode: { toolName } };
+}
+function handleTextChunk(chunk, role) {
+  return {
+    sessionUpdate: messageUpdateType(role),
+    content: text(chunk.text)
+  };
+}
+function handleImageChunk(chunk, role) {
+  return {
+    sessionUpdate: messageUpdateType(role),
+    content: image(
+      chunk.source.type === "base64" ? chunk.source.data ?? "" : "",
+      chunk.source.type === "base64" ? chunk.source.media_type ?? "" : "",
+      chunk.source.type === "url" ? chunk.source.url : void 0
+    )
+  };
+}
+function handleThinkingChunk(chunk) {
+  return {
+    sessionUpdate: "agent_thought_chunk",
+    content: text(chunk.thinking)
+  };
+}
+function handleToolUseChunk(chunk, ctx) {
+  ctx.toolUseCache[chunk.id] = chunk;
+  if (chunk.name === "TodoWrite") {
+    const input = chunk.input;
+    if (Array.isArray(input.todos)) {
+      return {
+        sessionUpdate: "plan",
+        entries: planEntries(chunk.input)
+      };
+    }
+    return null;
+  }
+  registerHookCallback(chunk.id, {
+    onPostToolUseHook: async (toolUseId, _toolInput, toolResponse) => {
+      const toolUse = ctx.toolUseCache[toolUseId];
+      if (toolUse) {
+        await ctx.client.sessionUpdate({
+          sessionId: ctx.sessionId,
+          update: {
+            _meta: toolMeta(toolUse.name, toolResponse),
+            toolCallId: toolUseId,
+            sessionUpdate: "tool_call_update"
+          }
+        });
+      } else {
+        ctx.logger.error(
+          `Got a tool response for tool use that wasn't tracked: ${toolUseId}`
+        );
+      }
+    }
+  });
+  let rawInput;
+  try {
+    rawInput = JSON.parse(JSON.stringify(chunk.input));
+  } catch {
+  }
+  return {
+    _meta: toolMeta(chunk.name),
+    toolCallId: chunk.id,
+    sessionUpdate: "tool_call",
+    rawInput,
+    status: "pending",
+    ...toolInfoFromToolUse(chunk, ctx.fileContentCache, ctx.logger)
+  };
+}
+function handleToolResultChunk(chunk, ctx) {
+  const toolUse = ctx.toolUseCache[chunk.tool_use_id];
+  if (!toolUse) {
+    ctx.logger.error(
+      `Got a tool result for tool use that wasn't tracked: ${chunk.tool_use_id}`
+    );
+    return null;
+  }
+  if (toolUse.name === "TodoWrite") {
+    return null;
+  }
+  return {
+    _meta: toolMeta(toolUse.name),
+    toolCallId: chunk.tool_use_id,
+    sessionUpdate: "tool_call_update",
+    status: chunk.is_error ? "failed" : "completed",
+    ...toolUpdateFromToolResult(
+      chunk,
+      toolUse
+    )
+  };
+}
+function processContentChunk(chunk, role, ctx) {
+  switch (chunk.type) {
+    case "text":
+    case "text_delta":
+      return handleTextChunk(chunk, role);
+    case "image":
+      return handleImageChunk(chunk, role);
+    case "thinking":
+    case "thinking_delta":
+      return handleThinkingChunk(chunk);
+    case "tool_use":
+    case "server_tool_use":
+    case "mcp_tool_use":
+      return handleToolUseChunk(chunk, ctx);
+    case "tool_result":
+    case "tool_search_tool_result":
+    case "web_fetch_tool_result":
+    case "web_search_tool_result":
+    case "code_execution_tool_result":
+    case "bash_code_execution_tool_result":
+    case "text_editor_code_execution_tool_result":
+    case "mcp_tool_result":
+      return handleToolResultChunk(
+        chunk,
+        ctx
+      );
+    case "document":
+    case "search_result":
+    case "redacted_thinking":
+    case "input_json_delta":
+    case "citations_delta":
+    case "signature_delta":
+    case "container_upload":
+      return null;
+    default:
+      unreachable(chunk, ctx.logger);
+      return null;
+  }
+}
+function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentCache, client, logger) {
+  if (typeof content === "string") {
+    return [
+      {
+        sessionId,
+        update: {
+          sessionUpdate: messageUpdateType(role),
+          content: text(content)
+        }
+      }
+    ];
+  }
+  const ctx = {
+    sessionId,
+    toolUseCache,
+    fileContentCache,
+    client,
+    logger
+  };
+  const output = [];
+  for (const chunk of content) {
+    const update = processContentChunk(chunk, role, ctx);
+    if (update) {
+      output.push({ sessionId, update });
+    }
+  }
+  return output;
+}
+function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileContentCache, client, logger) {
+  const event = message.event;
+  switch (event.type) {
+    case "content_block_start":
+      return toAcpNotifications(
+        [event.content_block],
+        "assistant",
+        sessionId,
+        toolUseCache,
+        fileContentCache,
+        client,
+        logger
+      );
+    case "content_block_delta":
+      return toAcpNotifications(
+        [event.delta],
+        "assistant",
+        sessionId,
+        toolUseCache,
+        fileContentCache,
+        client,
+        logger
+      );
+    case "message_start":
+    case "message_delta":
+    case "message_stop":
+    case "content_block_stop":
+      return [];
+    default:
+      unreachable(event, logger);
+      return [];
+  }
+}
+async function handleSystemMessage(message, context) {
+  const { session, sessionId, client, logger } = context;
+  switch (message.subtype) {
+    case "init":
+      if (message.session_id && session && !session.sessionId) {
+        session.sessionId = message.session_id;
+        if (session.taskRunId) {
+          await client.extNotification("_posthog/sdk_session", {
+            taskRunId: session.taskRunId,
+            sessionId: message.session_id,
+            adapter: "claude"
+          });
+        }
+      }
+      break;
+    case "compact_boundary":
+      await client.extNotification("_posthog/compact_boundary", {
+        sessionId,
+        trigger: message.compact_metadata.trigger,
+        preTokens: message.compact_metadata.pre_tokens
+      });
+      break;
+    case "hook_response":
+      logger.info("Hook response received", {
+        hookName: message.hook_name,
+        hookEvent: message.hook_event
+      });
+      break;
+    case "status":
+      if (message.status === "compacting") {
+        logger.info("Session compacting started", { sessionId });
+        await client.extNotification("_posthog/status", {
+          sessionId,
+          status: "compacting"
+        });
+      }
+      break;
+    case "task_notification": {
+      logger.info("Task notification received", {
+        sessionId,
+        taskId: message.task_id,
+        status: message.status,
+        summary: message.summary
+      });
+      await client.extNotification("_posthog/task_notification", {
+        sessionId,
+        taskId: message.task_id,
+        status: message.status,
+        summary: message.summary,
+        outputFile: message.output_file
+      });
+      break;
+    }
+    default:
+      break;
+  }
+}
+function handleResultMessage(message, context) {
+  const { session } = context;
+  if (session.cancelled) {
+    return {
+      shouldStop: true,
+      stopReason: "cancelled"
+    };
+  }
+  switch (message.subtype) {
+    case "success": {
+      if (message.result.includes("Please run /login")) {
+        return {
+          shouldStop: true,
+          error: RequestError.authRequired()
+        };
+      }
+      if (message.is_error) {
+        return {
+          shouldStop: true,
+          error: RequestError.internalError(void 0, message.result)
+        };
+      }
+      return { shouldStop: true, stopReason: "end_turn" };
+    }
+    case "error_during_execution":
+      if (message.is_error) {
+        return {
+          shouldStop: true,
+          error: RequestError.internalError(
+            void 0,
+            message.errors.join(", ") || message.subtype
+          )
+        };
+      }
+      return { shouldStop: true, stopReason: "end_turn" };
+    case "error_max_budget_usd":
+    case "error_max_turns":
+    case "error_max_structured_output_retries":
+      if (message.is_error) {
+        return {
+          shouldStop: true,
+          error: RequestError.internalError(
+            void 0,
+            message.errors.join(", ") || message.subtype
+          )
+        };
+      }
+      return { shouldStop: true, stopReason: "max_turn_requests" };
+    default:
+      return { shouldStop: false };
+  }
+}
+async function handleStreamEvent(message, context) {
+  const { sessionId, client, toolUseCache, fileContentCache, logger } = context;
+  for (const notification of streamEventToAcpNotifications(
+    message,
+    sessionId,
+    toolUseCache,
+    fileContentCache,
+    client,
+    logger
+  )) {
+    await client.sessionUpdate(notification);
+    context.session.notificationHistory.push(notification);
+  }
+}
+function hasLocalCommandStdout(content) {
+  return typeof content === "string" && content.includes("<local-command-stdout>");
+}
+function hasLocalCommandStderr(content) {
+  return typeof content === "string" && content.includes("<local-command-stderr>");
+}
+function isSimpleUserMessage(message) {
+  return message.type === "user" && (typeof message.message.content === "string" || Array.isArray(message.message.content) && message.message.content.length === 1 && message.message.content[0].type === "text");
+}
+function isLoginRequiredMessage(message) {
+  return message.type === "assistant" && message.message.model === "<synthetic>" && Array.isArray(message.message.content) && message.message.content.length === 1 && message.message.content[0].type === "text" && message.message.content[0].text?.includes("Please run /login") === true;
+}
+function shouldSkipUserAssistantMessage(message) {
+  return hasLocalCommandStdout(message.message.content) || hasLocalCommandStderr(message.message.content) || isSimpleUserMessage(message) || isLoginRequiredMessage(message);
+}
+function logSpecialMessages(message, logger) {
+  const content = message.message.content;
+  if (hasLocalCommandStdout(content) && typeof content === "string") {
+    logger.info(content);
+  }
+  if (hasLocalCommandStderr(content) && typeof content === "string") {
+    logger.error(content);
+  }
+}
+function filterMessageContent(content) {
+  if (!Array.isArray(content)) {
+    return content;
+  }
+  return content.filter(
+    (block) => block.type !== "text" && block.type !== "thinking"
+  );
+}
+async function handleUserAssistantMessage(message, context) {
+  const { session, sessionId, client, toolUseCache, fileContentCache, logger } = context;
+  if (session.cancelled) {
+    return {};
+  }
+  if (shouldSkipUserAssistantMessage(message)) {
+    logSpecialMessages(message, logger);
+    if (isLoginRequiredMessage(message)) {
+      return { shouldStop: true, error: RequestError.authRequired() };
+    }
+    return {};
+  }
+  const content = message.message.content;
+  const contentToProcess = filterMessageContent(content);
+  for (const notification of toAcpNotifications(
+    contentToProcess,
+    message.message.role,
+    sessionId,
+    toolUseCache,
+    fileContentCache,
+    client,
+    logger
+  )) {
+    await client.sessionUpdate(notification);
+    session.notificationHistory.push(notification);
+  }
+  return {};
+}
+
+// src/adapters/claude/mcp/tool-metadata.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var mcpToolMetadataCache = /* @__PURE__ */ new Map();
+function buildToolKey(serverName, toolName) {
+  return `mcp__${serverName}__${toolName}`;
+}
+function isHttpMcpServer(config) {
+  return config.type === "http" && typeof config.url === "string";
+}
+async function fetchToolsFromHttpServer(_serverName, config) {
+  const transport = new StreamableHTTPClientTransport(new URL(config.url), {
+    requestInit: {
+      headers: config.headers || {}
+    }
+  });
+  const client = new Client({
+    name: "twig-metadata-fetcher",
+    version: "1.0.0"
+  });
+  try {
+    await client.connect(transport);
+    const result = await client.listTools();
+    return result.tools;
+  } finally {
+    await client.close().catch(() => {
+    });
+  }
+}
+function extractToolMetadata(tool) {
+  return {
+    readOnly: tool.annotations?.readOnlyHint === true
+  };
+}
+async function fetchMcpToolMetadata(mcpServers, logger = new Logger({ debug: false, prefix: "[McpToolMetadata]" })) {
+  const fetchPromises = [];
+  for (const [serverName, config] of Object.entries(mcpServers)) {
+    if (!isHttpMcpServer(config)) {
+      continue;
+    }
+    const fetchPromise = fetchToolsFromHttpServer(serverName, config).then((tools) => {
+      const toolCount = tools.length;
+      const readOnlyCount = tools.filter(
+        (t) => t.annotations?.readOnlyHint === true
+      ).length;
+      for (const tool of tools) {
+        const toolKey = buildToolKey(serverName, tool.name);
+        mcpToolMetadataCache.set(toolKey, extractToolMetadata(tool));
+      }
+      logger.info("Fetched MCP tool metadata", {
+        serverName,
+        toolCount,
+        readOnlyCount
+      });
+    }).catch((error) => {
+      logger.error("Failed to fetch MCP tool metadata", {
+        serverName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+    fetchPromises.push(fetchPromise);
+  }
+  await Promise.all(fetchPromises);
+}
+function isMcpToolReadOnly(toolName) {
+  const metadata = mcpToolMetadataCache.get(toolName);
+  return metadata?.readOnly === true;
+}
+
+// src/adapters/claude/plan/utils.ts
+import * as os from "os";
+import * as path from "path";
+function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+}
+function getClaudePlansDir() {
+  return path.join(getClaudeConfigDir(), "plans");
+}
+function isClaudePlanFilePath(filePath) {
+  if (!filePath) return false;
+  const resolved = path.resolve(filePath);
+  const plansDir = path.resolve(getClaudePlansDir());
+  return resolved === plansDir || resolved.startsWith(plansDir + path.sep);
+}
+function isPlanReady(plan) {
+  if (!plan) return false;
+  const trimmed = plan.trim();
+  if (trimmed.length < 40) return false;
+  return /(^|\n)#{1,6}\s+\S/.test(trimmed);
+}
+function getLatestAssistantText(notifications) {
+  const chunks = [];
+  let started = false;
+  for (let i = notifications.length - 1; i >= 0; i -= 1) {
+    const update = notifications[i]?.update;
+    if (!update) continue;
+    if (update.sessionUpdate === "agent_message_chunk") {
+      started = true;
+      const content = update.content;
+      if (content?.type === "text" && content.text) {
+        chunks.push(content.text);
+      }
+      continue;
+    }
+    if (started) {
+      break;
+    }
+  }
+  if (chunks.length === 0) return null;
+  return chunks.reverse().join("");
+}
+
+// src/adapters/claude/questions/utils.ts
+import { z } from "zod";
+var OPTION_PREFIX = "option_";
+var QuestionOptionSchema = z.object({
+  label: z.string(),
+  description: z.string().optional()
+});
+var QuestionItemSchema = z.object({
+  question: z.string(),
+  header: z.string().optional(),
+  options: z.array(QuestionOptionSchema),
+  multiSelect: z.boolean().optional(),
+  completed: z.boolean().optional()
+});
+var QuestionMetaSchema = z.object({
+  questions: z.array(QuestionItemSchema)
+});
+function normalizeAskUserQuestionInput(input) {
+  if (input.questions && input.questions.length > 0) {
+    return input.questions;
+  }
+  if (input.question) {
+    return [
+      {
+        question: input.question,
+        header: input.header,
+        options: input.options || [],
+        multiSelect: input.multiSelect
+      }
+    ];
+  }
+  return null;
+}
+
+// src/execution-mode.ts
+var MODES = [
+  {
+    id: "default",
+    name: "Always Ask",
+    description: "Prompts for permission on first use of each tool"
+  },
+  {
+    id: "acceptEdits",
+    name: "Accept Edits",
+    description: "Automatically accepts file edit permissions for the session"
+  },
+  {
+    id: "plan",
+    name: "Plan Mode",
+    description: "Claude can analyze but not modify files or execute commands"
+  },
+  {
+    id: "bypassPermissions",
+    name: "Bypass Permissions",
+    description: "Skips all permission prompts"
+  }
+];
+var TWIG_EXECUTION_MODES = [
+  "default",
+  "acceptEdits",
+  "plan",
+  "bypassPermissions"
+];
+function getAvailableModes() {
+  return IS_ROOT ? MODES.filter((m) => m.id !== "bypassPermissions") : MODES;
+}
+
+// src/adapters/claude/tools.ts
+var READ_TOOLS = /* @__PURE__ */ new Set(["Read", "NotebookRead"]);
+var WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "Edit",
+  "Write",
+  "NotebookEdit"
+]);
+var BASH_TOOLS = /* @__PURE__ */ new Set([
+  "Bash",
+  "BashOutput",
+  "KillShell"
+]);
+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"]);
+var BASE_ALLOWED_TOOLS = [
+  ...READ_TOOLS,
+  ...SEARCH_TOOLS,
+  ...WEB_TOOLS,
+  ...AGENT_TOOLS
+];
+var AUTO_ALLOWED_TOOLS = {
+  default: new Set(BASE_ALLOWED_TOOLS),
+  acceptEdits: /* @__PURE__ */ new Set([...BASE_ALLOWED_TOOLS, ...WRITE_TOOLS]),
+  plan: new Set(BASE_ALLOWED_TOOLS)
+};
+function isToolAllowedForMode(toolName, mode) {
+  if (mode === "bypassPermissions") {
+    return true;
+  }
+  if (AUTO_ALLOWED_TOOLS[mode]?.has(toolName) === true) {
+    return true;
+  }
+  if (isMcpToolReadOnly(toolName)) {
+    return true;
+  }
+  return false;
+}
+
+// src/adapters/claude/permissions/permission-options.ts
+function permissionOptions(allowAlwaysLabel) {
+  return [
+    { kind: "allow_once", name: "Yes", optionId: "allow" },
+    { kind: "allow_always", name: allowAlwaysLabel, optionId: "allow_always" },
+    {
+      kind: "reject_once",
+      name: "No, and tell the agent what to do differently",
+      optionId: "reject",
+      _meta: { customInput: true }
+    }
+  ];
+}
+function buildPermissionOptions(toolName, toolInput, cwd) {
+  if (BASH_TOOLS.has(toolName)) {
+    const command = toolInput?.command;
+    const cmdName = command?.split(/\s+/)[0] ?? "this command";
+    const cwdLabel = cwd ? ` in ${cwd}` : "";
+    return permissionOptions(
+      `Yes, and don't ask again for \`${cmdName}\` commands${cwdLabel}`
+    );
+  }
+  if (toolName === "BashOutput") {
+    return permissionOptions("Yes, allow all background process reads");
+  }
+  if (toolName === "KillShell") {
+    return permissionOptions("Yes, allow killing processes");
+  }
+  if (WRITE_TOOLS.has(toolName)) {
+    return permissionOptions("Yes, allow all edits during this session");
+  }
+  if (READ_TOOLS.has(toolName)) {
+    return permissionOptions("Yes, allow all reads during this session");
+  }
+  if (SEARCH_TOOLS.has(toolName)) {
+    return permissionOptions("Yes, allow all searches during this session");
+  }
+  if (toolName === "WebFetch") {
+    const url = toolInput?.url;
+    let domain = "";
+    try {
+      domain = url ? new URL(url).hostname : "";
+    } catch {
+    }
+    return permissionOptions(
+      domain ? `Yes, allow all fetches from ${domain}` : "Yes, allow all fetches"
+    );
+  }
+  if (toolName === "WebSearch") {
+    return permissionOptions("Yes, allow all web searches");
+  }
+  if (toolName === "Task") {
+    return permissionOptions("Yes, allow all sub-tasks");
+  }
+  if (toolName === "TodoWrite") {
+    return permissionOptions("Yes, allow all todo updates");
+  }
+  return permissionOptions("Yes, always allow");
+}
+function buildExitPlanModePermissionOptions() {
+  return [
+    {
+      kind: "allow_always",
+      name: "Yes, and auto-accept edits",
+      optionId: "acceptEdits"
+    },
+    {
+      kind: "allow_once",
+      name: "Yes, and manually approve edits",
+      optionId: "default"
+    },
+    {
+      kind: "reject_once",
+      name: "No, keep planning",
+      optionId: "plan"
+    }
+  ];
+}
+
+// src/adapters/claude/permissions/permission-handlers.ts
+async function emitToolDenial(context, message) {
+  context.logger.info(`[canUseTool] Tool denied: ${context.toolName}`, {
+    message
+  });
+  await context.client.sessionUpdate({
+    sessionId: context.sessionId,
+    update: {
+      sessionUpdate: "tool_call_update",
+      toolCallId: context.toolUseID,
+      status: "failed",
+      content: [{ type: "content", content: text(message) }]
+    }
+  });
+}
+function getPlanFromFile(session, fileContentCache) {
+  return session.lastPlanContent || (session.lastPlanFilePath ? fileContentCache[session.lastPlanFilePath] : void 0);
+}
+function ensurePlanInInput(toolInput, fallbackPlan) {
+  const hasPlan = typeof toolInput?.plan === "string";
+  if (hasPlan || !fallbackPlan) {
+    return toolInput;
+  }
+  return { ...toolInput, plan: fallbackPlan };
+}
+function extractPlanText(input) {
+  const plan = input?.plan;
+  return typeof plan === "string" ? plan : void 0;
+}
+async function createPlanValidationError(message, context) {
+  await emitToolDenial(context, message);
+  return { behavior: "deny", message, interrupt: false };
+}
+async function validatePlanContent(planText, context) {
+  if (!planText) {
+    const message = `Plan not ready. Provide the full markdown plan in ExitPlanMode or write it to ${getClaudePlansDir()} before requesting approval.`;
+    return {
+      valid: false,
+      error: await createPlanValidationError(message, context)
+    };
+  }
+  if (!isPlanReady(planText)) {
+    const message = "Plan not ready. Provide the full markdown plan in ExitPlanMode before requesting approval.";
+    return {
+      valid: false,
+      error: await createPlanValidationError(message, context)
+    };
+  }
+  return { valid: true };
+}
+async function requestPlanApproval(context, updatedInput) {
+  const { client, sessionId, toolUseID, fileContentCache } = context;
+  const toolInfo = toolInfoFromToolUse(
+    { name: context.toolName, input: updatedInput },
+    fileContentCache,
+    context.logger
+  );
+  return await client.requestPermission({
+    options: buildExitPlanModePermissionOptions(),
+    sessionId,
+    toolCall: {
+      toolCallId: toolUseID,
+      title: toolInfo.title,
+      kind: toolInfo.kind,
+      content: toolInfo.content,
+      locations: toolInfo.locations,
+      rawInput: { ...updatedInput, toolName: context.toolName }
+    }
+  });
+}
+async function applyPlanApproval(response, context, updatedInput) {
+  const { session } = context;
+  if (response.outcome?.outcome === "selected" && (response.outcome.optionId === "default" || response.outcome.optionId === "acceptEdits")) {
+    session.permissionMode = response.outcome.optionId;
+    await session.query.setPermissionMode(response.outcome.optionId);
+    await context.emitConfigOptionsUpdate();
+    return {
+      behavior: "allow",
+      updatedInput,
+      updatedPermissions: context.suggestions ?? [
+        {
+          type: "setMode",
+          mode: response.outcome.optionId,
+          destination: "localSettings"
+        }
+      ]
+    };
+  }
+  const message = "User wants to continue planning. Please refine your plan based on any feedback provided, or ask clarifying questions if needed.";
+  await emitToolDenial(context, message);
+  return { behavior: "deny", message, interrupt: false };
+}
+async function handleEnterPlanModeTool(context) {
+  const { session, toolInput, logger } = context;
+  session.permissionMode = "plan";
+  await session.query.setPermissionMode("plan");
+  await context.emitConfigOptionsUpdate();
+  return {
+    behavior: "allow",
+    updatedInput: toolInput
+  };
+}
+async function handleExitPlanModeTool(context) {
+  const { session, toolInput, fileContentCache } = context;
+  const planFromFile = getPlanFromFile(session, fileContentCache);
+  const latestText = getLatestAssistantText(session.notificationHistory);
+  const fallbackPlan = planFromFile || (latestText ?? void 0);
+  const updatedInput = ensurePlanInInput(toolInput, fallbackPlan);
+  const planText = extractPlanText(updatedInput);
+  const validationResult = await validatePlanContent(planText, context);
+  if (!validationResult.valid) {
+    return validationResult.error;
+  }
+  const response = await requestPlanApproval(context, updatedInput);
+  return await applyPlanApproval(response, context, updatedInput);
+}
+function buildQuestionOptions(question) {
+  return (question.options || []).map((opt, idx) => ({
+    kind: "allow_once",
+    name: opt.label,
+    optionId: `${OPTION_PREFIX}${idx}`,
+    _meta: opt.description ? { description: opt.description } : void 0
+  }));
+}
+async function handleAskUserQuestionTool(context) {
+  const input = context.toolInput;
+  context.logger.info("[AskUserQuestion] Received input", { input });
+  const questions = normalizeAskUserQuestionInput(input);
+  context.logger.info("[AskUserQuestion] Normalized questions", { questions });
+  if (!questions || questions.length === 0) {
+    context.logger.warn("[AskUserQuestion] No questions found in input");
+    return {
+      behavior: "deny",
+      message: "No questions provided",
+      interrupt: true
+    };
+  }
+  const { client, sessionId, toolUseID, toolInput, fileContentCache } = context;
+  const firstQuestion = questions[0];
+  const options = buildQuestionOptions(firstQuestion);
+  const toolInfo = toolInfoFromToolUse(
+    { name: context.toolName, input: toolInput },
+    fileContentCache,
+    context.logger
+  );
+  const response = await client.requestPermission({
+    options,
+    sessionId,
+    toolCall: {
+      toolCallId: toolUseID,
+      title: firstQuestion.question,
+      kind: "other",
+      content: toolInfo.content,
+      _meta: {
+        twigToolKind: "question",
+        questions
+      }
+    }
+  });
+  if (response.outcome?.outcome !== "selected") {
+    return {
+      behavior: "deny",
+      message: "User cancelled the questions",
+      interrupt: true
+    };
+  }
+  const answers = response._meta?.answers;
+  if (!answers || Object.keys(answers).length === 0) {
+    return {
+      behavior: "deny",
+      message: "User did not provide answers",
+      interrupt: true
+    };
+  }
+  return {
+    behavior: "allow",
+    updatedInput: {
+      ...context.toolInput,
+      answers
+    }
+  };
+}
+async function handleDefaultPermissionFlow(context) {
+  const {
+    session,
+    toolName,
+    toolInput,
+    toolUseID,
+    client,
+    sessionId,
+    fileContentCache,
+    suggestions
+  } = context;
+  const toolInfo = toolInfoFromToolUse(
+    { name: toolName, input: toolInput },
+    fileContentCache,
+    context.logger
+  );
+  const options = buildPermissionOptions(
+    toolName,
+    toolInput,
+    session?.cwd
+  );
+  const response = await client.requestPermission({
+    options,
+    sessionId,
+    toolCall: {
+      toolCallId: toolUseID,
+      title: toolInfo.title,
+      kind: toolInfo.kind,
+      content: toolInfo.content,
+      locations: toolInfo.locations,
+      rawInput: toolInput
+    }
+  });
+  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: suggestions ?? [
+          {
+            type: "addRules",
+            rules: [{ toolName }],
+            behavior: "allow",
+            destination: "localSettings"
+          }
+        ]
+      };
+    }
+    return {
+      behavior: "allow",
+      updatedInput: toolInput
+    };
+  } else {
+    const message = "User refused permission to run tool";
+    await emitToolDenial(context, message);
+    return {
+      behavior: "deny",
+      message,
+      interrupt: true
+    };
+  }
+}
+function handlePlanFileException(context) {
+  const { session, toolName, toolInput } = context;
+  if (session.permissionMode !== "plan" || !WRITE_TOOLS.has(toolName)) {
+    return null;
+  }
+  const filePath = toolInput?.file_path;
+  if (!isClaudePlanFilePath(filePath)) {
+    return null;
+  }
+  session.lastPlanFilePath = filePath;
+  const content = toolInput?.content;
+  if (typeof content === "string") {
+    session.lastPlanContent = content;
+  }
+  return {
+    behavior: "allow",
+    updatedInput: toolInput
+  };
+}
+async function canUseTool(context) {
+  const { toolName, toolInput, session } = context;
+  if (isToolAllowedForMode(toolName, session.permissionMode)) {
+    return {
+      behavior: "allow",
+      updatedInput: toolInput
+    };
+  }
+  if (toolName === "EnterPlanMode") {
+    return handleEnterPlanModeTool(context);
+  }
+  if (toolName === "ExitPlanMode") {
+    return handleExitPlanModeTool(context);
+  }
+  if (toolName === "AskUserQuestion") {
+    return handleAskUserQuestionTool(context);
+  }
+  const planFileResult = handlePlanFileException(context);
+  if (planFileResult) {
+    return planFileResult;
+  }
+  return handleDefaultPermissionFlow(context);
+}
+
+// src/adapters/claude/session/commands.ts
+var UNSUPPORTED_COMMANDS = [
+  "context",
+  "cost",
+  "login",
+  "logout",
+  "output-style:new",
+  "release-notes",
+  "todos"
+];
+async function getAvailableSlashCommands(q) {
+  const commands = await q.supportedCommands();
+  return commands.map((command) => {
+    const input = command.argumentHint ? { hint: command.argumentHint } : null;
+    let name = command.name;
+    if (command.name.endsWith(" (MCP)")) {
+      name = `mcp:${name.replace(" (MCP)", "")}`;
+    }
+    return {
+      name,
+      description: command.description || "",
+      input
+    };
+  }).filter(
+    (command) => !UNSUPPORTED_COMMANDS.includes(command.name)
+  );
+}
+
+// src/adapters/claude/session/mcp-config.ts
+function parseMcpServers(params) {
+  const mcpServers = {};
+  if (!Array.isArray(params.mcpServers)) {
+    return mcpServers;
+  }
+  for (const server of params.mcpServers) {
+    if ("type" in server) {
+      mcpServers[server.name] = {
+        type: server.type,
+        url: server.url,
+        headers: server.headers ? Object.fromEntries(server.headers.map((e) => [e.name, e.value])) : void 0
+      };
+    } else {
+      mcpServers[server.name] = {
+        type: "stdio",
+        command: server.command,
+        args: server.args,
+        env: server.env ? Object.fromEntries(server.env.map((e) => [e.name, e.value])) : void 0
+      };
+    }
+  }
+  return mcpServers;
+}
+
+// src/adapters/claude/session/models.ts
+var GATEWAY_TO_SDK_MODEL = {
+  "claude-opus-4-5": "opus",
+  "claude-opus-4-6": "opus",
+  "claude-sonnet-4-5": "sonnet",
+  "claude-haiku-4-5": "haiku"
+};
+function toSdkModelId(modelId) {
+  return GATEWAY_TO_SDK_MODEL[modelId] ?? modelId;
+}
+
+// src/adapters/claude/session/options.ts
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+var BRANCH_NAMING_INSTRUCTIONS = `
+# Branch Naming
+
+Before pushing a "workspace-*" branch to origin, rename it to something descriptive based on the work done. Do this automatically without asking the user.
+`;
+function buildSystemPrompt(customPrompt) {
+  const defaultPrompt = {
+    type: "preset",
+    preset: "claude_code",
+    append: BRANCH_NAMING_INSTRUCTIONS
+  };
+  if (!customPrompt) {
+    return defaultPrompt;
+  }
+  if (typeof customPrompt === "string") {
+    return customPrompt + BRANCH_NAMING_INSTRUCTIONS;
+  }
+  if (typeof customPrompt === "object" && customPrompt !== null && "append" in customPrompt && typeof customPrompt.append === "string") {
+    return {
+      ...defaultPrompt,
+      append: customPrompt.append + BRANCH_NAMING_INSTRUCTIONS
+    };
+  }
+  return defaultPrompt;
+}
+function buildMcpServers(userServers, acpServers) {
+  return {
+    ...userServers || {},
+    ...acpServers
+  };
+}
+function buildEnvironment() {
+  return {
+    ...process.env,
+    ELECTRON_RUN_AS_NODE: "1",
+    CLAUDE_CODE_ENABLE_ASK_USER_QUESTION_TOOL: "true"
+  };
+}
+function buildHooks(userHooks, onModeChange) {
+  return {
+    ...userHooks,
+    PostToolUse: [
+      ...userHooks?.PostToolUse || [],
+      {
+        hooks: [createPostToolUseHook({ onModeChange })]
+      }
+    ]
+  };
+}
+function getAbortController(userProvidedController) {
+  const controller = userProvidedController ?? new AbortController();
+  if (controller.signal.aborted) {
+    throw new Error("Cancelled");
+  }
+  return controller;
+}
+function buildSpawnWrapper(sessionId, onProcessSpawned, onProcessExited) {
+  return (spawnOpts) => {
+    const child = spawn(spawnOpts.command, spawnOpts.args, {
+      cwd: spawnOpts.cwd,
+      env: spawnOpts.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (child.pid) {
+      onProcessSpawned({
+        pid: child.pid,
+        command: `${spawnOpts.command} ${spawnOpts.args.join(" ")}`,
+        sessionId
+      });
+    }
+    if (onProcessExited) {
+      child.on("exit", () => {
+        if (child.pid) {
+          onProcessExited(child.pid);
+        }
+      });
+    }
+    if (spawnOpts.signal) {
+      spawnOpts.signal.addEventListener("abort", () => {
+        child.kill("SIGTERM");
+      });
+    }
+    return {
+      stdin: child.stdin,
+      stdout: child.stdout,
+      get killed() {
+        return child.killed;
+      },
+      get exitCode() {
+        return child.exitCode;
+      },
+      kill(signal) {
+        return child.kill(signal);
+      },
+      on(event, listener) {
+        child.on(event, listener);
+      },
+      once(event, listener) {
+        child.once(event, listener);
+      },
+      off(event, listener) {
+        child.off(event, listener);
+      }
+    };
+  };
+}
+function buildSessionOptions(params) {
+  const options = {
+    ...params.userProvidedOptions,
+    systemPrompt: params.systemPrompt ?? buildSystemPrompt(),
+    settingSources: ["user", "project", "local"],
+    stderr: (err) => params.logger.error(err),
+    cwd: params.cwd,
+    includePartialMessages: true,
+    allowDangerouslySkipPermissions: !IS_ROOT,
+    permissionMode: params.permissionMode,
+    canUseTool: params.canUseTool,
+    executable: "node",
+    mcpServers: buildMcpServers(
+      params.userProvidedOptions?.mcpServers,
+      params.mcpServers
+    ),
+    env: buildEnvironment(),
+    hooks: buildHooks(params.userProvidedOptions?.hooks, params.onModeChange),
+    abortController: getAbortController(
+      params.userProvidedOptions?.abortController
+    ),
+    ...params.onProcessSpawned && {
+      spawnClaudeCodeProcess: buildSpawnWrapper(
+        params.sessionId ?? "unknown",
+        params.onProcessSpawned,
+        params.onProcessExited
+      )
+    }
+  };
+  if (process.env.CLAUDE_CODE_EXECUTABLE) {
+    options.pathToClaudeCodeExecutable = process.env.CLAUDE_CODE_EXECUTABLE;
+  }
+  if (params.sessionId) {
+    options.resume = params.sessionId;
+  }
+  if (params.additionalDirectories) {
+    options.additionalDirectories = params.additionalDirectories;
+  }
+  clearStatsigCache();
+  return options;
+}
+function clearStatsigCache() {
+  const statsigPath = path2.join(
+    process.env.CLAUDE_CONFIG_DIR || path2.join(os2.homedir(), ".claude"),
+    "statsig"
+  );
+  try {
+    if (fs.existsSync(statsigPath)) {
+      fs.rmSync(statsigPath, { recursive: true, force: true });
+    }
+  } catch {
+  }
+}
+
+// src/adapters/claude/claude-agent.ts
+var ClaudeAcpAgent = class extends BaseAcpAgent {
+  adapterName = "claude";
+  toolUseCache;
+  backgroundTerminals = {};
+  clientCapabilities;
+  logWriter;
+  processCallbacks;
+  lastSentConfigOptions;
+  constructor(client, logWriter, processCallbacks) {
+    super(client);
+    this.logWriter = logWriter;
+    this.processCallbacks = processCallbacks;
+    this.toolUseCache = {};
+    this.logger = new Logger({ debug: true, prefix: "[ClaudeAcpAgent]" });
+  }
+  async initialize(request) {
+    this.clientCapabilities = request.clientCapabilities;
+    return {
+      protocolVersion: 1,
+      agentCapabilities: {
+        promptCapabilities: {
+          image: true,
+          embeddedContext: true
+        },
+        mcpCapabilities: {
+          http: true,
+          sse: true
+        },
+        loadSession: true,
+        _meta: {
+          posthog: {
+            resumeSession: true
+          }
+        }
+      },
+      agentInfo: {
+        name: package_default.name,
+        title: "Claude Code",
+        version: package_default.version
+      },
+      authMethods: [
+        {
+          id: "claude-login",
+          name: "Log in with Claude Code",
+          description: "Run `claude /login` in the terminal"
+        }
+      ]
+    };
+  }
+  async authenticate(_params) {
+    throw new Error("Method not implemented.");
+  }
+  async newSession(params) {
+    this.checkAuthStatus();
+    const meta = params._meta;
+    const internalSessionId = uuidv7();
+    const permissionMode = "default";
+    const mcpServers = parseMcpServers(params);
+    await fetchMcpToolMetadata(mcpServers, this.logger);
+    const options = buildSessionOptions({
+      cwd: params.cwd,
+      mcpServers,
+      permissionMode,
+      canUseTool: this.createCanUseTool(internalSessionId),
+      logger: this.logger,
+      systemPrompt: buildSystemPrompt(meta?.systemPrompt),
+      userProvidedOptions: meta?.claudeCode?.options,
+      onModeChange: this.createOnModeChange(internalSessionId),
+      onProcessSpawned: this.processCallbacks?.onProcessSpawned,
+      onProcessExited: this.processCallbacks?.onProcessExited
+    });
+    const input = new Pushable();
+    const q = query({ prompt: input, options });
+    const session = this.createSession(
+      internalSessionId,
+      q,
+      input,
+      permissionMode,
+      params.cwd,
+      options.abortController
+    );
+    session.taskRunId = meta?.taskRunId;
+    this.registerPersistence(
+      internalSessionId,
+      meta
+    );
+    const modelOptions = await this.getModelConfigOptions();
+    session.modelId = modelOptions.currentModelId;
+    await this.trySetModel(q, modelOptions.currentModelId);
+    this.sendAvailableCommandsUpdate(
+      internalSessionId,
+      await getAvailableSlashCommands(q)
+    );
+    return {
+      sessionId: internalSessionId,
+      configOptions: await this.buildConfigOptions(modelOptions)
+    };
+  }
+  async loadSession(params) {
+    return this.resumeSession(params);
+  }
+  async resumeSession(params) {
+    const { sessionId: internalSessionId } = params;
+    if (this.sessionId === internalSessionId) {
+      return {};
+    }
+    const meta = params._meta;
+    const mcpServers = parseMcpServers(params);
+    await fetchMcpToolMetadata(mcpServers, this.logger);
+    const { query: q, session } = await this.initializeQuery({
+      internalSessionId,
+      cwd: params.cwd,
+      permissionMode: "default",
+      mcpServers,
+      systemPrompt: buildSystemPrompt(meta?.systemPrompt),
+      userProvidedOptions: meta?.claudeCode?.options,
+      sessionId: meta?.sessionId,
+      additionalDirectories: meta?.claudeCode?.options?.additionalDirectories
+    });
+    session.taskRunId = meta?.taskRunId;
+    if (meta?.sessionId) {
+      session.sessionId = meta.sessionId;
+    }
+    this.registerPersistence(
+      internalSessionId,
+      meta
+    );
+    this.sendAvailableCommandsUpdate(
+      internalSessionId,
+      await getAvailableSlashCommands(q)
+    );
+    return {
+      configOptions: await this.buildConfigOptions()
+    };
+  }
+  async prompt(params) {
+    this.session.cancelled = false;
+    this.session.interruptReason = void 0;
+    await this.broadcastUserMessage(params);
+    this.session.input.push(promptToClaude(params));
+    return this.processMessages(params.sessionId);
+  }
+  async setSessionConfigOption(params) {
+    const configId = params.configId;
+    const value = params.value;
+    if (configId === "mode") {
+      const modeId = value;
+      if (!TWIG_EXECUTION_MODES.includes(modeId)) {
+        throw new Error("Invalid Mode");
+      }
+      this.session.permissionMode = modeId;
+      await this.session.query.setPermissionMode(modeId);
+    } else if (configId === "model") {
+      await this.setModelWithFallback(this.session.query, value);
+      this.session.modelId = value;
+    } else {
+      throw new Error("Unsupported config option");
+    }
+    await this.emitConfigOptionsUpdate();
+    return { configOptions: await this.buildConfigOptions() };
+  }
+  async interruptSession() {
+    await this.session.query.interrupt();
+  }
+  async extMethod(method, params) {
+    if (method === "_posthog/session/resume") {
+      const result = await this.resumeSession(
+        params
+      );
+      return {
+        _meta: {
+          configOptions: result.configOptions
+        }
+      };
+    }
+    throw RequestError2.methodNotFound(method);
+  }
+  createSession(sessionId, q, input, permissionMode, cwd, abortController) {
+    const session = {
+      query: q,
+      input,
+      cancelled: false,
+      permissionMode,
+      cwd,
+      notificationHistory: [],
+      abortController
+    };
+    this.session = session;
+    this.sessionId = sessionId;
+    return session;
+  }
+  async initializeQuery(config) {
+    const input = new Pushable();
+    const options = buildSessionOptions({
+      cwd: config.cwd,
+      mcpServers: config.mcpServers,
+      permissionMode: config.permissionMode,
+      canUseTool: this.createCanUseTool(config.internalSessionId),
+      logger: this.logger,
+      systemPrompt: config.systemPrompt,
+      userProvidedOptions: config.userProvidedOptions,
+      sessionId: config.sessionId,
+      additionalDirectories: config.additionalDirectories,
+      onModeChange: this.createOnModeChange(config.internalSessionId),
+      onProcessSpawned: this.processCallbacks?.onProcessSpawned,
+      onProcessExited: this.processCallbacks?.onProcessExited
+    });
+    const q = query({ prompt: input, options });
+    const abortController = options.abortController;
+    const session = this.createSession(
+      config.internalSessionId,
+      q,
+      input,
+      config.permissionMode,
+      config.cwd,
+      abortController
+    );
+    return { query: q, input, session };
+  }
+  createCanUseTool(sessionId) {
+    return async (toolName, toolInput, { suggestions, toolUseID }) => canUseTool({
+      session: this.session,
+      toolName,
+      toolInput,
+      toolUseID,
+      suggestions,
+      client: this.client,
+      sessionId,
+      fileContentCache: this.fileContentCache,
+      logger: this.logger,
+      emitConfigOptionsUpdate: () => this.emitConfigOptionsUpdate(sessionId)
+    });
+  }
+  createOnModeChange(sessionId) {
+    return async (newMode) => {
+      if (this.session) {
+        this.session.permissionMode = newMode;
+      }
+      await this.emitConfigOptionsUpdate(sessionId);
+    };
+  }
+  async buildConfigOptions(modelOptionsOverride) {
+    const options = [];
+    const modeOptions = getAvailableModes().map((mode) => ({
+      value: mode.id,
+      name: mode.name,
+      description: mode.description ?? void 0
+    }));
+    options.push({
+      id: "mode",
+      name: "Approval Preset",
+      type: "select",
+      currentValue: this.session.permissionMode,
+      options: modeOptions,
+      category: "mode",
+      description: "Choose an approval and sandboxing preset for your session"
+    });
+    const modelOptions = modelOptionsOverride ?? await this.getModelConfigOptions(this.session.modelId);
+    this.session.modelId = modelOptions.currentModelId;
+    options.push({
+      id: "model",
+      name: "Model",
+      type: "select",
+      currentValue: modelOptions.currentModelId,
+      options: modelOptions.options,
+      category: "model",
+      description: "Choose which model Claude should use"
+    });
+    return options;
+  }
+  async emitConfigOptionsUpdate(sessionId) {
+    const configOptions = await this.buildConfigOptions();
+    const serialized = JSON.stringify(configOptions);
+    if (this.lastSentConfigOptions && JSON.stringify(this.lastSentConfigOptions) === serialized) {
+      return;
+    }
+    this.lastSentConfigOptions = configOptions;
+    await this.client.sessionUpdate({
+      sessionId: sessionId ?? this.sessionId,
+      update: {
+        sessionUpdate: "config_option_update",
+        configOptions
+      }
+    });
+  }
+  checkAuthStatus() {
+    const backupExists = fs2.existsSync(
+      path3.resolve(os3.homedir(), ".claude.json.backup")
+    );
+    const configExists = fs2.existsSync(
+      path3.resolve(os3.homedir(), ".claude.json")
+    );
+    if (backupExists && !configExists) {
+      throw RequestError2.authRequired();
+    }
+  }
+  async trySetModel(q, modelId) {
+    try {
+      await this.setModelWithFallback(q, modelId);
+    } catch (err) {
+      this.logger.warn("Failed to set model", { modelId, error: err });
+    }
+  }
+  async setModelWithFallback(q, modelId) {
+    try {
+      await q.setModel(modelId);
+      return;
+    } catch (err) {
+      const fallback = toSdkModelId(modelId);
+      if (fallback === modelId) {
+        throw err;
+      }
+      await q.setModel(fallback);
+    }
+  }
+  registerPersistence(sessionId, meta) {
+    const persistence = meta?.persistence;
+    if (persistence && this.logWriter) {
+      this.logWriter.register(sessionId, persistence);
+    }
+  }
+  sendAvailableCommandsUpdate(sessionId, availableCommands) {
+    setTimeout(() => {
+      this.client.sessionUpdate({
+        sessionId,
+        update: {
+          sessionUpdate: "available_commands_update",
+          availableCommands
+        }
+      });
+    }, 0);
+  }
+  async broadcastUserMessage(params) {
+    for (const chunk of params.prompt) {
+      const notification = {
+        sessionId: params.sessionId,
+        update: {
+          sessionUpdate: "user_message_chunk",
+          content: chunk
+        }
+      };
+      await this.client.sessionUpdate(notification);
+      this.appendNotification(params.sessionId, notification);
+    }
+  }
+  async processMessages(sessionId) {
+    const context = {
+      session: this.session,
+      sessionId,
+      client: this.client,
+      toolUseCache: this.toolUseCache,
+      fileContentCache: this.fileContentCache,
+      logger: this.logger
+    };
+    while (true) {
+      const { value: message, done } = await this.session.query.next();
+      if (done || !message) {
+        return this.handleSessionEnd();
+      }
+      const response = await this.handleMessage(message, context);
+      if (response) {
+        return response;
+      }
+    }
+  }
+  handleSessionEnd() {
+    if (this.session.cancelled) {
+      return {
+        stopReason: "cancelled",
+        _meta: this.session.interruptReason ? { interruptReason: this.session.interruptReason } : void 0
+      };
+    }
+    throw new Error("Session did not end in result");
+  }
+  async handleMessage(message, context) {
+    switch (message.type) {
+      case "system":
+        await handleSystemMessage(message, context);
+        return null;
+      case "result": {
+        const result = handleResultMessage(message, context);
+        if (result.error) throw result.error;
+        if (result.shouldStop) {
+          return {
+            stopReason: result.stopReason
+          };
+        }
+        return null;
+      }
+      case "stream_event":
+        await handleStreamEvent(message, context);
+        return null;
+      case "user":
+      case "assistant": {
+        const result = await handleUserAssistantMessage(message, context);
+        if (result.error) throw result.error;
+        if (result.shouldStop) {
+          return { stopReason: "end_turn" };
+        }
+        return null;
+      }
+      case "tool_progress":
+      case "auth_status":
+        return null;
+      default:
+        unreachable(message, this.logger);
+        return null;
+    }
+  }
+};
+
+// src/adapters/codex/spawn.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+function buildConfigArgs(options) {
+  const args = [];
+  args.push("-c", `features.remote_models=false`);
+  if (options.apiBaseUrl) {
+    args.push("-c", `model_provider="posthog"`);
+    args.push("-c", `model_providers.posthog.name="PostHog Gateway"`);
+    args.push("-c", `model_providers.posthog.base_url="${options.apiBaseUrl}"`);
+    args.push("-c", `model_providers.posthog.wire_api="responses"`);
+    args.push(
+      "-c",
+      `model_providers.posthog.env_key="POSTHOG_GATEWAY_API_KEY"`
+    );
+  }
+  if (options.model) {
+    args.push("-c", `model="${options.model}"`);
+  }
+  return args;
+}
+function findCodexBinary(options) {
+  const configArgs = buildConfigArgs(options);
+  if (options.binaryPath && existsSync3(options.binaryPath)) {
+    return { command: options.binaryPath, args: configArgs };
+  }
+  return { command: "npx", args: ["@zed-industries/codex-acp", ...configArgs] };
+}
+function spawnCodexProcess(options) {
+  const logger = options.logger ?? new Logger({ debug: true, prefix: "[CodexSpawn]" });
+  const env = { ...process.env };
+  delete env.ELECTRON_RUN_AS_NODE;
+  delete env.ELECTRON_NO_ASAR;
+  if (options.apiKey) {
+    env.POSTHOG_GATEWAY_API_KEY = options.apiKey;
+  }
+  const { command, args } = findCodexBinary(options);
+  logger.info("Spawning codex-acp process", {
+    command,
+    args,
+    cwd: options.cwd,
+    hasApiBaseUrl: !!options.apiBaseUrl,
+    hasApiKey: !!options.apiKey,
+    binaryPath: options.binaryPath
+  });
+  const child = spawn2(command, args, {
+    cwd: options.cwd,
+    env,
+    stdio: ["pipe", "pipe", "pipe"],
+    detached: process.platform !== "win32"
+  });
+  child.stderr?.on("data", (data) => {
+    logger.debug("codex-acp stderr:", data.toString());
+  });
+  child.on("error", (err) => {
+    logger.error("codex-acp process error:", err);
+  });
+  child.on("exit", (code, signal) => {
+    logger.info("codex-acp process exited", { code, signal });
+    if (child.pid && options.processCallbacks?.onProcessExited) {
+      options.processCallbacks.onProcessExited(child.pid);
+    }
+  });
+  if (!child.stdin || !child.stdout) {
+    throw new Error("Failed to get stdio streams from codex-acp process");
+  }
+  if (child.pid && options.processCallbacks?.onProcessSpawned) {
+    options.processCallbacks.onProcessSpawned({
+      pid: child.pid,
+      command
+    });
+  }
+  return {
+    process: child,
+    stdin: child.stdin,
+    stdout: child.stdout,
+    kill: () => {
+      logger.info("Killing codex-acp process", { pid: child.pid });
+      child.stdin?.destroy();
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      child.kill("SIGTERM");
+    }
+  };
+}
+
+// src/adapters/acp-connection.ts
+function isGroupedOptions(options) {
+  return options.length > 0 && "group" in options[0];
+}
+function filterModelConfigOptions(msg, allowedModelIds) {
+  const payload = msg;
+  const configOptions = payload.result?.configOptions ?? payload.params?.update?.configOptions;
+  if (!configOptions) return null;
+  const filtered = configOptions.map((opt) => {
+    if (opt.category !== "model" || !opt.options) return opt;
+    const options = opt.options;
+    if (isGroupedOptions(options)) {
+      const filteredOptions2 = options.map((group) => ({
+        ...group,
+        options: (group.options ?? []).filter(
+          (o) => o?.value && allowedModelIds.has(o.value)
+        )
+      }));
+      const flat = filteredOptions2.flatMap((g) => g.options ?? []);
+      const currentAllowed2 = opt.currentValue && allowedModelIds.has(opt.currentValue);
+      const nextCurrent2 = currentAllowed2 || flat.length === 0 ? opt.currentValue : flat[0]?.value;
+      return {
+        ...opt,
+        currentValue: nextCurrent2,
+        options: filteredOptions2
+      };
+    }
+    const valueOptions = options;
+    const filteredOptions = valueOptions.filter(
+      (o) => o?.value && allowedModelIds.has(o.value)
+    );
+    const currentAllowed = opt.currentValue && allowedModelIds.has(opt.currentValue);
+    const nextCurrent = currentAllowed || filteredOptions.length === 0 ? opt.currentValue : filteredOptions[0]?.value;
+    return {
+      ...opt,
+      currentValue: nextCurrent,
+      options: filteredOptions
+    };
+  });
+  if (payload.result?.configOptions) {
+    return { ...msg, result: { ...payload.result, configOptions: filtered } };
+  }
+  if (payload.params?.update?.configOptions) {
+    return {
+      ...msg,
+      params: {
+        ...payload.params,
+        update: { ...payload.params.update, configOptions: filtered }
+      }
+    };
+  }
+  return null;
+}
+function extractReasoningEffort(configOptions) {
+  if (!configOptions) return void 0;
+  const option = configOptions.find((opt) => opt.id === "reasoning_effort");
+  return option?.currentValue ?? void 0;
+}
+function createAcpConnection(config = {}) {
+  const adapterType = config.adapter ?? "claude";
+  if (adapterType === "codex") {
+    return createCodexConnection(config);
+  }
+  return createClaudeConnection(config);
+}
+function createClaudeConnection(config) {
+  const logger = config.logger?.child("AcpConnection") ?? new Logger({ debug: true, prefix: "[AcpConnection]" });
+  const streams = createBidirectionalStreams();
+  const { logWriter } = config;
+  let agentWritable = streams.agent.writable;
+  let clientWritable = streams.client.writable;
+  if (config.taskRunId && logWriter) {
+    if (!logWriter.isRegistered(config.taskRunId)) {
+      logWriter.register(config.taskRunId, {
+        taskId: config.taskId ?? config.taskRunId,
+        runId: config.taskRunId,
+        deviceType: config.deviceType
+      });
+    }
+    agentWritable = createTappedWritableStream(streams.agent.writable, {
+      onMessage: (line) => {
+        logWriter.appendRawLine(config.taskRunId, line);
+      },
+      logger
+    });
+    clientWritable = createTappedWritableStream(streams.client.writable, {
+      onMessage: (line) => {
+        logWriter.appendRawLine(config.taskRunId, line);
+      },
+      logger
+    });
+  } else {
+    logger.info("Tapped streams NOT enabled", {
+      hasTaskRunId: !!config.taskRunId,
+      hasLogWriter: !!logWriter
+    });
+  }
+  const agentStream = ndJsonStream(agentWritable, streams.agent.readable);
+  let agent = null;
+  const agentConnection = new AgentSideConnection((client) => {
+    agent = new ClaudeAcpAgent(client, logWriter, config.processCallbacks);
+    logger.info(`Created ${agent.adapterName} agent`);
+    return agent;
+  }, agentStream);
+  return {
+    agentConnection,
+    clientStreams: {
+      readable: streams.client.readable,
+      writable: clientWritable
+    },
+    cleanup: async () => {
+      logger.info("Cleaning up ACP connection");
+      if (agent) {
+        await agent.closeSession();
+      }
+      try {
+        await streams.client.writable.close();
+      } catch {
+      }
+      try {
+        await streams.agent.writable.close();
+      } catch {
+      }
+    }
+  };
+}
+function createCodexConnection(config) {
+  const logger = config.logger?.child("CodexConnection") ?? new Logger({ debug: true, prefix: "[CodexConnection]" });
+  const { logWriter } = config;
+  const allowedModelIds = config.allowedModelIds;
+  const codexProcess = spawnCodexProcess({
+    ...config.codexOptions,
+    logger,
+    processCallbacks: config.processCallbacks
+  });
+  let clientReadable = nodeReadableToWebReadable(codexProcess.stdout);
+  let clientWritable = nodeWritableToWebWritable(codexProcess.stdin);
+  let isLoadingSession = false;
+  let loadRequestId = null;
+  let newSessionRequestId = null;
+  let sdkSessionEmitted = false;
+  const reasoningEffortBySessionId = /* @__PURE__ */ new Map();
+  let injectedConfigId = 0;
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let readBuffer = "";
+  const taskRunId = config.taskRunId;
+  const filteringReadable = clientReadable.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        readBuffer += decoder.decode(chunk, { stream: true });
+        const lines = readBuffer.split("\n");
+        readBuffer = lines.pop() ?? "";
+        const outputLines = [];
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) {
+            outputLines.push(line);
+            continue;
+          }
+          let shouldFilter = false;
+          try {
+            const msg = JSON.parse(trimmed);
+            const sessionId = msg?.params?.sessionId ?? msg?.result?.sessionId ?? null;
+            const configOptions = msg?.result?.configOptions ?? msg?.params?.update?.configOptions;
+            if (sessionId && configOptions) {
+              const effort = extractReasoningEffort(configOptions);
+              if (effort) {
+                reasoningEffortBySessionId.set(sessionId, effort);
+              }
+            }
+            if (!sdkSessionEmitted && newSessionRequestId !== null && msg.id === newSessionRequestId && "result" in msg) {
+              const sessionId2 = msg.result?.sessionId;
+              if (sessionId2 && taskRunId) {
+                const sdkSessionNotification = {
+                  jsonrpc: "2.0",
+                  method: POSTHOG_NOTIFICATIONS.SDK_SESSION,
+                  params: {
+                    taskRunId,
+                    sessionId: sessionId2,
+                    adapter: "codex"
+                  }
+                };
+                outputLines.push(JSON.stringify(sdkSessionNotification));
+                sdkSessionEmitted = true;
+              }
+              newSessionRequestId = null;
+            }
+            if (isLoadingSession) {
+              if (msg.id === loadRequestId && "result" in msg) {
+                logger.debug("session/load complete, resuming stream");
+                isLoadingSession = false;
+                loadRequestId = null;
+              } else if (msg.method === "session/update") {
+                shouldFilter = true;
+              }
+            }
+            if (!shouldFilter && allowedModelIds && allowedModelIds.size > 0) {
+              const updated = filterModelConfigOptions(msg, allowedModelIds);
+              if (updated) {
+                outputLines.push(JSON.stringify(updated));
+                continue;
+              }
+            }
+          } catch {
+          }
+          if (!shouldFilter) {
+            outputLines.push(line);
+            const isChunkNoise = trimmed.includes('"sessionUpdate":"agent_message_chunk"') || trimmed.includes('"sessionUpdate":"agent_thought_chunk"');
+            if (!isChunkNoise) {
+              logger.debug("codex-acp stdout:", trimmed);
+            }
+          }
+        }
+        if (outputLines.length > 0) {
+          const output = `${outputLines.join("\n")}
+`;
+          controller.enqueue(encoder.encode(output));
+        }
+      },
+      flush(controller) {
+        if (readBuffer.trim()) {
+          controller.enqueue(encoder.encode(readBuffer));
+        }
+      }
+    })
+  );
+  clientReadable = filteringReadable;
+  const originalWritable = clientWritable;
+  clientWritable = new WritableStream({
+    write(chunk) {
+      const text2 = decoder.decode(chunk, { stream: true });
+      const trimmed = text2.trim();
+      logger.debug("codex-acp stdin:", trimmed);
+      try {
+        const msg = JSON.parse(trimmed);
+        if (msg.method === "session/set_config_option" && msg.params?.configId === "reasoning_effort" && msg.params?.sessionId && msg.params?.value) {
+          reasoningEffortBySessionId.set(
+            msg.params.sessionId,
+            msg.params.value
+          );
+        }
+        if (msg.method === "session/prompt" && msg.params?.sessionId) {
+          const effort = reasoningEffortBySessionId.get(msg.params.sessionId);
+          if (effort) {
+            const injection = {
+              jsonrpc: "2.0",
+              id: `reasoning_effort_${Date.now()}_${injectedConfigId++}`,
+              method: "session/set_config_option",
+              params: {
+                sessionId: msg.params.sessionId,
+                configId: "reasoning_effort",
+                value: effort
+              }
+            };
+            const injectionLine = `${JSON.stringify(injection)}
+`;
+            const writer2 = originalWritable.getWriter();
+            return writer2.write(encoder.encode(injectionLine)).then(() => writer2.releaseLock()).then(() => {
+              const nextWriter = originalWritable.getWriter();
+              return nextWriter.write(chunk).finally(() => nextWriter.releaseLock());
+            });
+          }
+        }
+        if (msg.method === "session/new" && msg.id) {
+          logger.debug("session/new detected, tracking request ID");
+          newSessionRequestId = msg.id;
+        } else if (msg.method === "session/load" && msg.id) {
+          logger.debug("session/load detected, pausing stream updates");
+          isLoadingSession = true;
+          loadRequestId = msg.id;
+        }
+      } catch {
+      }
+      const writer = originalWritable.getWriter();
+      return writer.write(chunk).finally(() => writer.releaseLock());
+    },
+    close() {
+      const writer = originalWritable.getWriter();
+      return writer.close().finally(() => writer.releaseLock());
+    }
+  });
+  const shouldTapLogs = config.taskRunId && logWriter;
+  if (shouldTapLogs) {
+    const taskRunId2 = config.taskRunId;
+    if (!logWriter.isRegistered(taskRunId2)) {
+      logWriter.register(taskRunId2, {
+        taskId: config.taskId ?? taskRunId2,
+        runId: taskRunId2
+      });
+    }
+    clientWritable = createTappedWritableStream(clientWritable, {
+      onMessage: (line) => {
+        logWriter.appendRawLine(taskRunId2, line);
+      },
+      logger
+    });
+    const originalReadable = clientReadable;
+    const logDecoder = new TextDecoder();
+    let logBuffer = "";
+    clientReadable = originalReadable.pipeThrough(
+      new TransformStream({
+        transform(chunk, controller) {
+          logBuffer += logDecoder.decode(chunk, { stream: true });
+          const lines = logBuffer.split("\n");
+          logBuffer = lines.pop() ?? "";
+          for (const line of lines) {
+            if (line.trim()) {
+              logWriter.appendRawLine(taskRunId2, line);
+            }
+          }
+          controller.enqueue(chunk);
+        },
+        flush() {
+          if (logBuffer.trim()) {
+            logWriter.appendRawLine(taskRunId2, logBuffer);
+          }
+        }
+      })
+    );
+  } else {
+    logger.info("Tapped streams NOT enabled for Codex", {
+      hasTaskRunId: !!config.taskRunId,
+      hasLogWriter: !!logWriter
+    });
+  }
+  return {
+    agentConnection: void 0,
+    clientStreams: {
+      readable: clientReadable,
+      writable: clientWritable
+    },
+    cleanup: async () => {
+      logger.info("Cleaning up Codex connection");
+      codexProcess.kill();
+      try {
+        await clientWritable.close();
+      } catch {
+      }
+    }
+  };
+}
+
+// src/utils/gateway.ts
+function getLlmGatewayUrl(posthogHost) {
+  const url = new URL(posthogHost);
+  const hostname = url.hostname;
+  if (hostname === "localhost" || hostname === "127.0.0.1") {
+    return `${url.protocol}//localhost:3308/twig`;
+  }
+  if (hostname === "host.docker.internal") {
+    return `${url.protocol}//host.docker.internal:3308/twig`;
+  }
+  const region = hostname.match(/^(us|eu)\.posthog\.com$/)?.[1] ?? "us";
+  return `https://gateway.${region}.posthog.com/twig`;
+}
+
+// src/posthog-api.ts
+var PostHogAPIClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  get baseUrl() {
+    const host = this.config.apiUrl.endsWith("/") ? this.config.apiUrl.slice(0, -1) : this.config.apiUrl;
+    return host;
+  }
+  get headers() {
+    return {
+      Authorization: `Bearer ${this.config.getApiKey()}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async apiRequest(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        ...this.headers,
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      let errorMessage;
+      try {
+        const errorResponse = await response.json();
+        errorMessage = `Failed request: [${response.status}] ${JSON.stringify(errorResponse)}`;
+      } catch {
+        errorMessage = `Failed request: [${response.status}] ${response.statusText}`;
+      }
+      throw new Error(errorMessage);
+    }
+    return response.json();
+  }
+  getTeamId() {
+    return this.config.projectId;
+  }
+  getApiKey() {
+    return this.config.getApiKey();
+  }
+  getLlmGatewayUrl() {
+    return getLlmGatewayUrl(this.baseUrl);
+  }
+  async getTask(taskId) {
+    const teamId = this.getTeamId();
+    return this.apiRequest(`/api/projects/${teamId}/tasks/${taskId}/`);
+  }
+  async getTaskRun(taskId, runId) {
+    const teamId = this.getTeamId();
+    return this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`
+    );
+  }
+  async updateTaskRun(taskId, runId, payload) {
+    const teamId = this.getTeamId();
+    return this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(payload)
+      }
+    );
+  }
+  async appendTaskRunLog(taskId, runId, entries) {
+    const teamId = this.getTeamId();
+    return this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/append_log/`,
+      {
+        method: "POST",
+        body: JSON.stringify({ entries })
+      }
+    );
+  }
+  async uploadTaskArtifacts(taskId, runId, artifacts) {
+    if (!artifacts.length) {
+      return [];
+    }
+    const teamId = this.getTeamId();
+    const response = await this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/artifacts/`,
+      {
+        method: "POST",
+        body: JSON.stringify({ artifacts })
+      }
+    );
+    return response.artifacts ?? [];
+  }
+  async getArtifactPresignedUrl(taskId, runId, storagePath) {
+    const teamId = this.getTeamId();
+    try {
+      const response = await this.apiRequest(
+        `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/artifacts/presign/`,
+        {
+          method: "POST",
+          body: JSON.stringify({ storage_path: storagePath })
+        }
+      );
+      return response.url;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Download artifact content by storage path
+   * Gets a presigned URL and fetches the content
+   */
+  async downloadArtifact(taskId, runId, storagePath) {
+    const url = await this.getArtifactPresignedUrl(taskId, runId, storagePath);
+    if (!url) {
+      return null;
+    }
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to download artifact: ${response.status}`);
+      }
+      return response.arrayBuffer();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Fetch logs for a task run via the logs API endpoint
+   * @param taskRun - The task run to fetch logs for
+   * @returns Array of stored entries, or empty array if no logs available
+   */
+  async fetchTaskRunLogs(taskRun) {
+    const teamId = this.getTeamId();
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/projects/${teamId}/tasks/${taskRun.task}/runs/${taskRun.id}/logs`,
+        { headers: this.headers }
+      );
+      if (!response.ok) {
+        if (response.status === 404) {
+          return [];
+        }
+        throw new Error(
+          `Failed to fetch logs: ${response.status} ${response.statusText}`
+        );
+      }
+      const content = await response.text();
+      if (!content.trim()) {
+        return [];
+      }
+      return content.trim().split("\n").map((line) => JSON.parse(line));
+    } catch (error) {
+      throw new Error(
+        `Failed to fetch task run logs: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+};
+
+// src/otel-log-writer.ts
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider
+} from "@opentelemetry/sdk-logs";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+var OtelLogWriter = class {
+  loggerProvider;
+  logger;
+  constructor(config, sessionContext, _debugLogger) {
+    const logsPath = config.logsPath ?? "/i/v1/agent-logs";
+    const exporter = new OTLPLogExporter({
+      url: `${config.posthogHost}${logsPath}`,
+      headers: { Authorization: `Bearer ${config.apiKey}` }
+    });
+    const processor = new BatchLogRecordProcessor(exporter, {
+      scheduledDelayMillis: config.flushIntervalMs ?? 500
+    });
+    this.loggerProvider = new LoggerProvider({
+      resource: resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: "twig-agent",
+        run_id: sessionContext.runId,
+        task_id: sessionContext.taskId,
+        device_type: sessionContext.deviceType ?? "local"
+      }),
+      processors: [processor]
+    });
+    this.logger = this.loggerProvider.getLogger("agent-session");
+  }
+  /**
+   * Emit an agent event to PostHog Logs via OTEL.
+   */
+  emit(entry) {
+    const { notification } = entry;
+    const eventType = notification.notification.method;
+    this.logger.emit({
+      severityNumber: SeverityNumber.INFO,
+      severityText: "INFO",
+      body: JSON.stringify(notification),
+      attributes: {
+        event_type: eventType
+      }
+    });
+  }
+  async flush() {
+    await this.loggerProvider.forceFlush();
+  }
+  async shutdown() {
+    await this.loggerProvider.shutdown();
+  }
+};
+
+// src/session-log-writer.ts
+var SessionLogWriter = class {
+  posthogAPI;
+  otelConfig;
+  pendingEntries = /* @__PURE__ */ new Map();
+  flushTimeouts = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  logger;
+  constructor(options = {}) {
+    this.posthogAPI = options.posthogAPI;
+    this.otelConfig = options.otelConfig;
+    this.logger = options.logger ?? new Logger({ debug: false, prefix: "[SessionLogWriter]" });
+  }
+  async flushAll() {
+    const flushPromises = [];
+    for (const sessionId of this.sessions.keys()) {
+      flushPromises.push(this.flush(sessionId));
+    }
+    await Promise.all(flushPromises);
+  }
+  register(sessionId, context) {
+    if (this.sessions.has(sessionId)) {
+      return;
+    }
+    let otelWriter;
+    if (this.otelConfig) {
+      otelWriter = new OtelLogWriter(
+        this.otelConfig,
+        context,
+        this.logger.child(`OtelWriter:${sessionId}`)
+      );
+    }
+    this.sessions.set(sessionId, { context, otelWriter });
+  }
+  isRegistered(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  appendRawLine(sessionId, line) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return;
+    }
+    try {
+      const message = JSON.parse(line);
+      const entry = {
+        type: "notification",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        notification: message
+      };
+      if (session.otelWriter) {
+        session.otelWriter.emit({ notification: 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", {
+        sessionId,
+        lineLength: line.length
+      });
+    }
+  }
+  async flush(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    if (session.otelWriter) {
+      await session.otelWriter.flush();
+    }
+    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);
+    }
+    try {
+      await this.posthogAPI.appendTaskRunLog(
+        session.context.taskId,
+        session.context.runId,
+        pending
+      );
+    } catch (error) {
+      this.logger.error("Failed to persist session logs:", error);
+    }
+  }
+  scheduleFlush(sessionId) {
+    const existing = this.flushTimeouts.get(sessionId);
+    if (existing) clearTimeout(existing);
+    const timeout = setTimeout(() => this.flush(sessionId), 500);
+    this.flushTimeouts.set(sessionId, timeout);
+  }
+};
+
+// src/tree-tracker.ts
+import { isCommitOnRemote as gitIsCommitOnRemote } from "@twig/git/queries";
+
+// src/sagas/apply-snapshot-saga.ts
+import { mkdir, rm, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+import { Saga } from "@posthog/shared";
+import { ApplyTreeSaga as GitApplyTreeSaga } from "@twig/git/sagas/tree";
+var ApplySnapshotSaga = class extends Saga {
+  archivePath = null;
+  async execute(input) {
+    const { snapshot, repositoryPath, apiClient, taskId, runId } = input;
+    const tmpDir = join3(repositoryPath, ".posthog", "tmp");
+    if (!snapshot.archiveUrl) {
+      throw new Error("Cannot apply snapshot: no archive URL");
+    }
+    await this.step({
+      name: "create_tmp_dir",
+      execute: () => mkdir(tmpDir, { recursive: true }),
+      rollback: async () => {
+      }
+    });
+    this.archivePath = join3(tmpDir, `${snapshot.treeHash}.tar.gz`);
+    await this.step({
+      name: "download_archive",
+      execute: async () => {
+        const arrayBuffer = await apiClient.downloadArtifact(
+          taskId,
+          runId,
+          snapshot.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 writeFile(this.archivePath, binaryContent);
+      },
+      rollback: async () => {
+        if (this.archivePath) {
+          await rm(this.archivePath, { force: true }).catch(() => {
+          });
+        }
+      }
+    });
+    const gitApplySaga = new GitApplyTreeSaga(this.log);
+    const applyResult = await gitApplySaga.run({
+      baseDir: repositoryPath,
+      treeHash: snapshot.treeHash,
+      baseCommit: snapshot.baseCommit,
+      changes: snapshot.changes,
+      archivePath: this.archivePath
+    });
+    if (!applyResult.success) {
+      throw new Error(`Failed to apply tree: ${applyResult.error}`);
+    }
+    await rm(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 };
+  }
+};
+
+// src/sagas/capture-tree-saga.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile, rm as rm2 } from "fs/promises";
+import { join as join4 } from "path";
+import { Saga as Saga2 } from "@posthog/shared";
+import { CaptureTreeSaga as GitCaptureTreeSaga } from "@twig/git/sagas/tree";
+var CaptureTreeSaga = class extends Saga2 {
+  async execute(input) {
+    const {
+      repositoryPath,
+      lastTreeHash,
+      interrupted,
+      apiClient,
+      taskId,
+      runId
+    } = input;
+    const tmpDir = join4(repositoryPath, ".posthog", "tmp");
+    if (existsSync4(join4(repositoryPath, ".gitmodules"))) {
+      this.log.warn(
+        "Repository has submodules - snapshot may not capture submodule state"
+      );
+    }
+    const shouldArchive = !!apiClient;
+    const archivePath = shouldArchive ? join4(tmpDir, `tree-${Date.now()}.tar.gz`) : void 0;
+    const gitCaptureSaga = new GitCaptureTreeSaga(this.log);
+    const captureResult = await gitCaptureSaga.run({
+      baseDir: repositoryPath,
+      lastTreeHash,
+      archivePath
+    });
+    if (!captureResult.success) {
+      throw new Error(`Failed to capture tree: ${captureResult.error}`);
+    }
+    const {
+      snapshot: gitSnapshot,
+      archivePath: createdArchivePath,
+      changed
+    } = captureResult.data;
+    if (!changed || !gitSnapshot) {
+      this.log.debug("No changes since last capture", { lastTreeHash });
+      return { snapshot: null, newTreeHash: lastTreeHash };
+    }
+    let archiveUrl;
+    if (apiClient && createdArchivePath) {
+      try {
+        archiveUrl = await this.uploadArchive(
+          createdArchivePath,
+          gitSnapshot.treeHash,
+          apiClient,
+          taskId,
+          runId
+        );
+      } finally {
+        await rm2(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 };
+  }
+  async uploadArchive(archivePath, treeHash, apiClient, taskId, runId) {
+    const archiveUrl = await this.step({
+      name: "upload_archive",
+      execute: async () => {
+        const archiveContent = await readFile(archivePath);
+        const base64Content = archiveContent.toString("base64");
+        const artifacts = await apiClient.uploadTaskArtifacts(taskId, runId, [
+          {
+            name: `trees/${treeHash}.tar.gz`,
+            type: "tree_snapshot",
+            content: base64Content,
+            content_type: "application/gzip"
+          }
+        ]);
+        if (artifacts.length > 0 && artifacts[0].storage_path) {
+          this.log.info("Tree archive uploaded", {
+            storagePath: artifacts[0].storage_path,
+            treeHash
+          });
+          return artifacts[0].storage_path;
+        }
+        return void 0;
+      },
+      rollback: async () => {
+        await rm2(archivePath, { force: true }).catch(() => {
+        });
+      }
+    });
+    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 CaptureTreeSaga(this.logger);
+    const result = await saga.run({
+      repositoryPath: this.repositoryPath,
+      taskId: this.taskId,
+      runId: this.runId,
+      apiClient: this.apiClient,
+      lastTreeHash: this.lastTreeHash,
+      interrupted: options?.interrupted
+    });
+    if (!result.success) {
+      this.logger.error("Failed to capture tree", {
+        error: result.error,
+        failedStep: result.failedStep
+      });
+      throw new Error(
+        `Failed to capture tree at step '${result.failedStep}': ${result.error}`
+      );
+    }
+    if (result.data.newTreeHash !== null) {
+      this.lastTreeHash = result.data.newTreeHash;
+    }
+    return result.data.snapshot;
+  }
+  /**
+   * Download and apply a tree snapshot.
+   * Uses Saga pattern for atomic operation with rollback on failure.
+   */
+  async applyTreeSnapshot(snapshot) {
+    if (!this.apiClient) {
+      throw new Error("Cannot apply snapshot: API client not configured");
+    }
+    if (!snapshot.archiveUrl) {
+      this.logger.warn("Cannot apply snapshot: no archive URL", {
+        treeHash: snapshot.treeHash,
+        changes: snapshot.changes.length
+      });
+      throw new Error("Cannot apply snapshot: no archive URL");
+    }
+    const saga = new ApplySnapshotSaga(this.logger);
+    const result = await saga.run({
+      snapshot,
+      repositoryPath: this.repositoryPath,
+      apiClient: this.apiClient,
+      taskId: this.taskId,
+      runId: this.runId
+    });
+    if (!result.success) {
+      this.logger.error("Failed to apply tree snapshot", {
+        error: result.error,
+        failedStep: result.failedStep,
+        treeHash: snapshot.treeHash
+      });
+      throw new Error(
+        `Failed to apply snapshot at step '${result.failedStep}': ${result.error}`
+      );
+    }
+    this.lastTreeHash = result.data.treeHash;
+  }
+  /**
+   * Get the last captured tree hash.
+   */
+  getLastTreeHash() {
+    return this.lastTreeHash;
+  }
+  /**
+   * Set the last tree hash (used when resuming).
+   */
+  setLastTreeHash(hash) {
+    this.lastTreeHash = hash;
+  }
+};
+
+// src/utils/async-mutex.ts
+var AsyncMutex = class {
+  locked = false;
+  queue = [];
+  async acquire() {
+    if (!this.locked) {
+      this.locked = true;
+      return;
+    }
+    return new Promise((resolve3) => {
+      this.queue.push(resolve3);
+    });
+  }
+  release() {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.locked = false;
+    }
+  }
+  isLocked() {
+    return this.locked;
+  }
+  get queueLength() {
+    return this.queue.length;
+  }
+};
+
+// src/server/jwt.ts
+import jwt from "jsonwebtoken";
+import { z as z2 } from "zod";
+var SANDBOX_CONNECTION_AUDIENCE = "posthog:sandbox_connection";
+var userDataSchema = z2.object({
+  run_id: z2.string(),
+  task_id: z2.string(),
+  team_id: z2.number(),
+  user_id: z2.number(),
+  distinct_id: z2.string(),
+  mode: z2.enum(["interactive", "background"]).optional().default("interactive")
+});
+var jwtPayloadSchema = userDataSchema.extend({
+  exp: z2.number(),
+  iat: z2.number().optional(),
+  aud: z2.string().optional()
+});
+var JwtValidationError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "JwtValidationError";
+  }
+};
+function validateJwt(token, publicKey) {
+  try {
+    const decoded = jwt.verify(token, publicKey, {
+      algorithms: ["RS256"],
+      audience: SANDBOX_CONNECTION_AUDIENCE
+    });
+    const result = jwtPayloadSchema.safeParse(decoded);
+    if (!result.success) {
+      throw new JwtValidationError(
+        `Missing required fields: ${result.error.message}`,
+        "invalid_token"
+      );
+    }
+    return result.data;
+  } catch (error) {
+    if (error instanceof JwtValidationError) {
+      throw error;
+    }
+    if (error instanceof jwt.TokenExpiredError) {
+      throw new JwtValidationError("Token expired", "expired");
+    }
+    if (error instanceof jwt.JsonWebTokenError) {
+      throw new JwtValidationError("Invalid signature", "invalid_signature");
+    }
+    throw new JwtValidationError("Invalid token", "invalid_token");
+  }
+}
+
+// src/server/schemas.ts
+import { z as z3 } from "zod";
+var jsonRpcRequestSchema = z3.object({
+  jsonrpc: z3.literal("2.0"),
+  method: z3.string(),
+  params: z3.record(z3.unknown()).optional(),
+  id: z3.union([z3.string(), z3.number()]).optional()
+});
+var userMessageParamsSchema = z3.object({
+  content: z3.string().min(1, "Content is required")
+});
+var commandParamsSchemas = {
+  user_message: userMessageParamsSchema,
+  "posthog/user_message": userMessageParamsSchema,
+  cancel: z3.object({}).optional(),
+  "posthog/cancel": z3.object({}).optional(),
+  close: z3.object({}).optional(),
+  "posthog/close": z3.object({}).optional()
+};
+function validateCommandParams(method, params) {
+  const schema = commandParamsSchemas[method] ?? commandParamsSchemas[method.replace("posthog/", "")];
+  if (!schema) {
+    return { success: false, error: `Unknown method: ${method}` };
+  }
+  const result = schema.safeParse(params);
+  if (!result.success) {
+    return { success: false, error: result.error.message };
+  }
+  return { success: true, data: result.data };
+}
+
+// src/server/agent-server.ts
+var NdJsonTap = class {
+  constructor(onMessage) {
+    this.onMessage = onMessage;
+  }
+  decoder = new TextDecoder();
+  buffer = "";
+  process(chunk) {
+    this.buffer += this.decoder.decode(chunk, { stream: true });
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        this.onMessage(JSON.parse(line));
+      } catch {
+      }
+    }
+  }
+};
+function createTappedReadableStream(underlying, onMessage, logger) {
+  const reader = underlying.getReader();
+  const tap = new NdJsonTap(onMessage);
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        tap.process(value);
+        controller.enqueue(value);
+      } catch (error) {
+        logger?.debug("Read failed, closing stream", error);
+        controller.close();
+      }
+    },
+    cancel() {
+      reader.releaseLock();
+    }
+  });
+}
+function createTappedWritableStream2(underlying, onMessage, logger) {
+  const tap = new NdJsonTap(onMessage);
+  const mutex = new AsyncMutex();
+  return new WritableStream({
+    async write(chunk) {
+      tap.process(chunk);
+      await mutex.acquire();
+      try {
+        const writer = underlying.getWriter();
+        await writer.write(chunk);
+        writer.releaseLock();
+      } catch (error) {
+        logger?.debug("Write failed (stream may be closed)", error);
+      } finally {
+        mutex.release();
+      }
+    },
+    async close() {
+      await mutex.acquire();
+      try {
+        const writer = underlying.getWriter();
+        await writer.close();
+        writer.releaseLock();
+      } catch (error) {
+        logger?.debug("Close failed (stream may be closed)", error);
+      } finally {
+        mutex.release();
+      }
+    },
+    async abort(reason) {
+      await mutex.acquire();
+      try {
+        const writer = underlying.getWriter();
+        await writer.abort(reason);
+        writer.releaseLock();
+      } catch (error) {
+        logger?.debug("Abort failed (stream may be closed)", error);
+      } finally {
+        mutex.release();
+      }
+    }
+  });
+}
+var AgentServer = class {
+  config;
+  logger;
+  server = null;
+  session = null;
+  app;
+  posthogAPI;
+  constructor(config) {
+    this.config = config;
+    this.logger = new Logger({ debug: true, prefix: "[AgentServer]" });
+    this.posthogAPI = new PostHogAPIClient({
+      apiUrl: config.apiUrl,
+      projectId: config.projectId,
+      getApiKey: () => config.apiKey
+    });
+    this.app = this.createApp();
+  }
+  getEffectiveMode(payload) {
+    return payload.mode ?? this.config.mode;
+  }
+  createApp() {
+    const app = new Hono();
+    app.get("/health", (c) => {
+      return c.json({ status: "ok", hasSession: !!this.session });
+    });
+    app.get("/events", async (c) => {
+      let payload;
+      try {
+        payload = this.authenticateRequest(c.req.header.bind(c.req));
+      } catch (error) {
+        return c.json(
+          {
+            error: error instanceof JwtValidationError ? error.message : "Invalid token",
+            code: error instanceof JwtValidationError ? error.code : "invalid_token"
+          },
+          401
+        );
+      }
+      const stream = new ReadableStream({
+        start: async (controller) => {
+          const sseController = {
+            send: (data) => {
+              try {
+                controller.enqueue(
+                  new TextEncoder().encode(`data: ${JSON.stringify(data)}
+
+`)
+                );
+              } catch (error) {
+                this.logger.debug(
+                  "SSE send failed (stream may be closed)",
+                  error
+                );
+              }
+            },
+            close: () => {
+              try {
+                controller.close();
+              } catch (error) {
+                this.logger.debug("SSE close failed (already closed)", error);
+              }
+            }
+          };
+          if (!this.session || this.session.payload.run_id !== payload.run_id) {
+            await this.initializeSession(payload, sseController);
+          } else {
+            this.session.sseController = sseController;
+          }
+          this.sendSseEvent(sseController, {
+            type: "connected",
+            run_id: payload.run_id
+          });
+        },
+        cancel: () => {
+          this.logger.info("SSE connection closed");
+          if (this.session?.sseController) {
+            this.session.sseController = null;
+          }
+        }
+      });
+      return new Response(stream, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    });
+    app.post("/command", async (c) => {
+      let payload;
+      try {
+        payload = this.authenticateRequest(c.req.header.bind(c.req));
+      } catch (error) {
+        return c.json(
+          {
+            error: error instanceof JwtValidationError ? error.message : "Invalid token"
+          },
+          401
+        );
+      }
+      if (!this.session || this.session.payload.run_id !== payload.run_id) {
+        return c.json({ error: "No active session for this run" }, 400);
+      }
+      const rawBody = await c.req.json().catch(() => null);
+      const parseResult = jsonRpcRequestSchema.safeParse(rawBody);
+      if (!parseResult.success) {
+        return c.json({ error: "Invalid JSON-RPC request" }, 400);
+      }
+      const command = parseResult.data;
+      const paramsValidation = validateCommandParams(
+        command.method,
+        command.params ?? {}
+      );
+      if (!paramsValidation.success) {
+        return c.json(
+          {
+            jsonrpc: "2.0",
+            id: command.id,
+            error: {
+              code: -32602,
+              message: paramsValidation.error
+            }
+          },
+          200
+        );
+      }
+      try {
+        const result = await this.executeCommand(
+          command.method,
+          command.params || {}
+        );
+        return c.json({
+          jsonrpc: "2.0",
+          id: command.id,
+          result
+        });
+      } catch (error) {
+        return c.json({
+          jsonrpc: "2.0",
+          id: command.id,
+          error: {
+            code: -32e3,
+            message: error instanceof Error ? error.message : "Unknown error"
+          }
+        });
+      }
+    });
+    app.notFound((c) => {
+      return c.json({ error: "Not found" }, 404);
+    });
+    return app;
+  }
+  async start() {
+    await new Promise((resolve3) => {
+      this.server = serve(
+        {
+          fetch: this.app.fetch,
+          port: this.config.port
+        },
+        () => {
+          this.logger.info(`HTTP server listening on port ${this.config.port}`);
+          resolve3();
+        }
+      );
+    });
+    await this.autoInitializeSession();
+  }
+  async autoInitializeSession() {
+    const { taskId, runId, mode, projectId } = this.config;
+    this.logger.info("Auto-initializing session", { taskId, runId, mode });
+    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.info("Stopping agent server...");
+    if (this.session) {
+      await this.cleanupSession();
+    }
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+    this.logger.info("Agent server stopped");
+  }
+  authenticateRequest(getHeader) {
+    if (!this.config.jwtPublicKey) {
+      throw new JwtValidationError(
+        "Server not configured with JWT public key",
+        "server_error"
+      );
+    }
+    const authHeader = getHeader("authorization");
+    if (!authHeader?.startsWith("Bearer ")) {
+      throw new JwtValidationError(
+        "Missing authorization header",
+        "invalid_token"
+      );
+    }
+    const token = authHeader.slice(7);
+    return validateJwt(token, this.config.jwtPublicKey);
+  }
+  async executeCommand(method, params) {
+    if (!this.session) {
+      throw new Error("No active session");
+    }
+    switch (method) {
+      case POSTHOG_NOTIFICATIONS.USER_MESSAGE:
+      case "user_message": {
+        const content = params.content;
+        this.logger.info(
+          `Processing user message: ${content.substring(0, 100)}...`
+        );
+        const result = await this.session.clientConnection.prompt({
+          sessionId: this.session.payload.run_id,
+          prompt: [{ type: "text", text: content }]
+        });
+        return { stopReason: result.stopReason };
+      }
+      case POSTHOG_NOTIFICATIONS.CANCEL:
+      case "cancel": {
+        this.logger.info("Cancel requested");
+        await this.session.clientConnection.cancel({
+          sessionId: this.session.payload.run_id
+        });
+        return { cancelled: true };
+      }
+      case POSTHOG_NOTIFICATIONS.CLOSE:
+      case "close": {
+        this.logger.info("Close requested");
+        await this.cleanupSession();
+        return { closed: true };
+      }
+      default:
+        throw new Error(`Unknown method: ${method}`);
+    }
+  }
+  async initializeSession(payload, sseController) {
+    if (this.session) {
+      await this.cleanupSession();
+    }
+    this.logger.info("Initializing session", {
+      runId: payload.run_id,
+      taskId: payload.task_id
+    });
+    const deviceInfo = {
+      type: "cloud",
+      name: process.env.HOSTNAME || "cloud-sandbox"
+    };
+    this.configureEnvironment();
+    const treeTracker = new TreeTracker({
+      repositoryPath: this.config.repositoryPath,
+      taskId: payload.task_id,
+      runId: payload.run_id,
+      logger: new Logger({ debug: true, prefix: "[TreeTracker]" })
+    });
+    const _posthogAPI = new PostHogAPIClient({
+      apiUrl: this.config.apiUrl,
+      projectId: this.config.projectId,
+      getApiKey: () => this.config.apiKey
+    });
+    const logWriter = new SessionLogWriter({
+      otelConfig: {
+        posthogHost: this.config.apiUrl,
+        apiKey: this.config.apiKey,
+        logsPath: "/i/v1/agent-logs"
+      },
+      logger: new Logger({ debug: true, prefix: "[SessionLogWriter]" })
+    });
+    const acpConnection = createAcpConnection({
+      taskRunId: payload.run_id,
+      taskId: payload.task_id,
+      deviceType: deviceInfo.type,
+      logWriter
+    });
+    const onAcpMessage = (message) => {
+      this.broadcastEvent({
+        type: "notification",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        notification: message
+      });
+    };
+    const tappedReadable = createTappedReadableStream(
+      acpConnection.clientStreams.readable,
+      onAcpMessage,
+      this.logger
+    );
+    const tappedWritable = createTappedWritableStream2(
+      acpConnection.clientStreams.writable,
+      onAcpMessage,
+      this.logger
+    );
+    const clientStream = ndJsonStream2(tappedWritable, tappedReadable);
+    const clientConnection = new ClientSideConnection(
+      () => this.createCloudClient(payload),
+      clientStream
+    );
+    await clientConnection.initialize({
+      protocolVersion: PROTOCOL_VERSION,
+      clientCapabilities: {}
+    });
+    await clientConnection.newSession({
+      cwd: this.config.repositoryPath,
+      mcpServers: [],
+      _meta: { sessionId: payload.run_id }
+    });
+    this.session = {
+      payload,
+      acpConnection,
+      clientConnection,
+      treeTracker,
+      sseController,
+      deviceInfo,
+      logWriter
+    };
+    this.logger.info("Session initialized successfully");
+    await this.sendInitialTaskMessage(payload);
+  }
+  async sendInitialTaskMessage(payload) {
+    if (!this.session) return;
+    try {
+      this.logger.info("Fetching task details", { taskId: payload.task_id });
+      const task = await this.posthogAPI.getTask(payload.task_id);
+      if (!task.description) {
+        this.logger.warn("Task has no description, skipping initial message");
+        return;
+      }
+      this.logger.info("Sending initial task message", {
+        taskId: payload.task_id,
+        descriptionLength: task.description.length
+      });
+      const result = await this.session.clientConnection.prompt({
+        sessionId: payload.run_id,
+        prompt: [{ type: "text", text: task.description }]
+      });
+      this.logger.info("Initial task message completed", {
+        stopReason: result.stopReason
+      });
+      const mode = this.getEffectiveMode(payload);
+      if (mode === "background") {
+        await this.signalTaskComplete(payload, result.stopReason);
+      } else {
+        this.logger.info("Interactive mode - staying open for conversation");
+      }
+    } catch (error) {
+      this.logger.error("Failed to send initial task message", error);
+      const mode = this.getEffectiveMode(payload);
+      if (mode === "background") {
+        await this.signalTaskComplete(payload, "error");
+      }
+    }
+  }
+  async signalTaskComplete(payload, stopReason) {
+    const status = stopReason === "cancelled" ? "cancelled" : stopReason === "error" ? "failed" : "completed";
+    try {
+      await this.posthogAPI.updateTaskRun(payload.task_id, payload.run_id, {
+        status,
+        error_message: stopReason === "error" ? "Agent error" : void 0
+      });
+      this.logger.info("Task completion signaled", { status, stopReason });
+    } catch (error) {
+      this.logger.error("Failed to signal task completion", error);
+    }
+  }
+  configureEnvironment() {
+    const { apiKey, apiUrl, projectId } = this.config;
+    const gatewayUrl = process.env.LLM_GATEWAY_URL || getLlmGatewayUrl(apiUrl);
+    const openaiBaseUrl = gatewayUrl.endsWith("/v1") ? gatewayUrl : `${gatewayUrl}/v1`;
+    Object.assign(process.env, {
+      // PostHog
+      POSTHOG_API_KEY: apiKey,
+      POSTHOG_API_URL: apiUrl,
+      POSTHOG_API_HOST: apiUrl,
+      POSTHOG_AUTH_HEADER: `Bearer ${apiKey}`,
+      POSTHOG_PROJECT_ID: String(projectId),
+      // Anthropic
+      ANTHROPIC_API_KEY: apiKey,
+      ANTHROPIC_AUTH_TOKEN: apiKey,
+      ANTHROPIC_BASE_URL: gatewayUrl,
+      // OpenAI (for models like GPT-4, o1, etc.)
+      OPENAI_API_KEY: apiKey,
+      OPENAI_BASE_URL: openaiBaseUrl,
+      // Generic gateway
+      LLM_GATEWAY_URL: gatewayUrl
+    });
+  }
+  createCloudClient(payload) {
+    const mode = this.getEffectiveMode(payload);
+    return {
+      requestPermission: async (params) => {
+        this.logger.debug("Permission request", {
+          mode,
+          options: params.options
+        });
+        const allowOption = params.options.find(
+          (o) => o.kind === "allow_once" || o.kind === "allow_always"
+        );
+        return {
+          outcome: {
+            outcome: "selected",
+            optionId: allowOption?.optionId ?? params.options[0].optionId
+          }
+        };
+      },
+      sessionUpdate: async (params) => {
+        if (params.update?.sessionUpdate === "tool_call_update") {
+          const meta = params.update?._meta?.claudeCode;
+          const toolName = meta?.toolName;
+          const toolResponse = meta?.toolResponse;
+          if ((toolName === "Write" || toolName === "Edit") && toolResponse?.filePath) {
+            await this.captureTreeState();
+          }
+        }
+      }
+    };
+  }
+  async cleanupSession() {
+    if (!this.session) return;
+    this.logger.info("Cleaning up session");
+    try {
+      await this.captureTreeState();
+    } catch (error) {
+      this.logger.error("Failed to capture final tree state", error);
+    }
+    try {
+      await this.session.logWriter.flush(this.session.payload.run_id);
+    } catch (error) {
+      this.logger.error("Failed to flush session logs", error);
+    }
+    try {
+      await this.session.acpConnection.cleanup();
+    } catch (error) {
+      this.logger.error("Failed to cleanup ACP connection", error);
+    }
+    if (this.session.sseController) {
+      this.session.sseController.close();
+    }
+    this.session = null;
+  }
+  async captureTreeState() {
+    if (!this.session?.treeTracker) return;
+    try {
+      const snapshot = await this.session.treeTracker.captureTree({});
+      if (snapshot) {
+        const snapshotWithDevice = {
+          ...snapshot,
+          device: this.session.deviceInfo
+        };
+        this.broadcastEvent({
+          type: "notification",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          notification: {
+            jsonrpc: "2.0",
+            method: POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT,
+            params: snapshotWithDevice
+          }
+        });
+      }
+    } catch (error) {
+      this.logger.error("Failed to capture tree state", error);
+    }
+  }
+  broadcastEvent(event) {
+    if (this.session?.sseController) {
+      this.sendSseEvent(this.session.sseController, event);
+    }
+  }
+  sendSseEvent(controller, data) {
+    controller.send(data);
+  }
+};
+export {
+  AgentServer
+};
+//# sourceMappingURL=agent-server.js.map