@posthog/agent 2.0.1 → 2.0.3

package/dist/server/bin.js

@@ -1,4507 +0,0 @@
-#!/usr/bin/env node
-
-// src/server/bin.ts
-import { Command } from "commander";
-import { z as z4 } from "zod";
-
-// 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);
-  }
-};
-
-// src/server/bin.ts
-var envSchema = z4.object({
-  JWT_PUBLIC_KEY: z4.string({
-    required_error: "JWT_PUBLIC_KEY is required for authenticating client connections"
-  }).min(1, "JWT_PUBLIC_KEY cannot be empty"),
-  POSTHOG_API_URL: z4.string({
-    required_error: "POSTHOG_API_URL is required for LLM gateway communication"
-  }).url("POSTHOG_API_URL must be a valid URL"),
-  POSTHOG_PERSONAL_API_KEY: z4.string({
-    required_error: "POSTHOG_PERSONAL_API_KEY is required for authenticating with PostHog services"
-  }).min(1, "POSTHOG_PERSONAL_API_KEY cannot be empty"),
-  POSTHOG_PROJECT_ID: z4.string({
-    required_error: "POSTHOG_PROJECT_ID is required for routing requests to the correct project"
-  }).regex(/^\d+$/, "POSTHOG_PROJECT_ID must be a numeric string").transform((val) => parseInt(val, 10))
-});
-var program = new Command();
-program.name("agent-server").description("PostHog cloud agent server - runs in sandbox environments").option("--port <port>", "HTTP server port", "3001").option(
-  "--mode <mode>",
-  "Execution mode: interactive or background",
-  "interactive"
-).requiredOption("--repositoryPath <path>", "Path to the repository").requiredOption("--taskId <id>", "Task ID").requiredOption("--runId <id>", "Task run ID").action(async (options) => {
-  const envResult = envSchema.safeParse(process.env);
-  if (!envResult.success) {
-    const errors = envResult.error.issues.map((issue) => `  - ${issue.message}`).join("\n");
-    program.error(`Environment validation failed:
-${errors}`);
-    return;
-  }
-  const env = envResult.data;
-  const mode = options.mode === "background" ? "background" : "interactive";
-  const server = new AgentServer({
-    port: parseInt(options.port, 10),
-    jwtPublicKey: env.JWT_PUBLIC_KEY,
-    repositoryPath: options.repositoryPath,
-    apiUrl: env.POSTHOG_API_URL,
-    apiKey: env.POSTHOG_PERSONAL_API_KEY,
-    projectId: env.POSTHOG_PROJECT_ID,
-    mode,
-    taskId: options.taskId,
-    runId: options.runId
-  });
-  process.on("SIGINT", async () => {
-    await server.stop();
-    process.exit(0);
-  });
-  process.on("SIGTERM", async () => {
-    await server.stop();
-    process.exit(0);
-  });
-  await server.start();
-});
-program.parse();
-//# sourceMappingURL=bin.js.map