@posthog/agent 1.30.0 → 2.0.0

package/dist/index.js

@@ -46,16 +46,8 @@ var __callDispose = (stack, error, hasError) => {
 
 // src/acp-extensions.ts
 var POSTHOG_NOTIFICATIONS = {
-  /** Artifact produced during task execution (research, plan, etc.) */
-  ARTIFACT: "_posthog/artifact",
-  /** Phase has started (research, plan, build, etc.) */
-  PHASE_START: "_posthog/phase_start",
-  /** Phase has completed */
-  PHASE_COMPLETE: "_posthog/phase_complete",
   /** Git branch was created */
   BRANCH_CREATED: "_posthog/branch_created",
-  /** Pull request was created */
-  PR_CREATED: "_posthog/pr_created",
   /** Task run has started */
   RUN_STARTED: "_posthog/run_started",
   /** Task has completed */
@@ -65,24 +57,11 @@ var POSTHOG_NOTIFICATIONS = {
   /** Console/log output */
   CONSOLE: "_posthog/console",
   /** SDK session ID notification (for resumption) */
-  SDK_SESSION: "_posthog/sdk_session",
-  /** Sandbox execution output (stdout/stderr from Modal or Docker) */
-  SANDBOX_OUTPUT: "_posthog/sandbox_output"
+  SDK_SESSION: "_posthog/sdk_session"
 };
 
-// src/adapters/claude/claude.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import {
-  AgentSideConnection,
-  ndJsonStream,
-  RequestError
-} from "@agentclientprotocol/sdk";
-import {
-  query
-} from "@anthropic-ai/claude-agent-sdk";
-import { v7 as uuidv7 } from "uuid";
+// src/adapters/connection.ts
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 
 // src/utils/logger.ts
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
@@ -163,7 +142,7 @@ var Logger = class _Logger {
 
 // src/utils/tapped-stream.ts
 function createTappedWritableStream(underlying, options) {
-  const { onMessage, logger: logger2 } = options;
+  const { onMessage, logger } = options;
   const decoder = new TextDecoder();
   let buffer = "";
   let _messageCount = 0;
@@ -187,7 +166,7 @@ function createTappedWritableStream(underlying, options) {
       writer.releaseLock();
     },
     async abort(reason) {
-      logger2?.warn("Tapped stream aborted", { reason });
+      logger?.warn("Tapped stream aborted", { reason });
       const writer = underlying.getWriter();
       await writer.abort(reason);
       writer.releaseLock();
@@ -195,10 +174,22 @@ function createTappedWritableStream(underlying, options) {
   });
 }
 
+// src/adapters/claude/claude.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  RequestError
+} 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: "1.30.0",
+  version: "2.0.0",
   repository: "https://github.com/PostHog/array",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   main: "./dist/index.js",
@@ -311,14 +302,14 @@ var Pushable = class {
     };
   }
 };
-function unreachable(value, logger2) {
+function unreachable(value, logger) {
   let valueAsString;
   try {
     valueAsString = JSON.stringify(value);
   } catch {
     valueAsString = value;
   }
-  logger2.error(`Unexpected case: ${valueAsString}`);
+  logger.error(`Unexpected case: ${valueAsString}`);
 }
 function sleep(time) {
   return new Promise((resolve3) => setTimeout(resolve3, time));
@@ -1074,49 +1065,49 @@ No edits were applied.`
 }
 
 // src/adapters/claude/tools.ts
-function toolInfoFromToolUse(toolUse, cachedFileContent, logger2 = new Logger({ debug: false, prefix: "[ClaudeTools]" })) {
+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 ? input.description : "Task",
+        title: input?.description ? String(input.description) : "Task",
         kind: "think",
         content: input?.prompt ? [
           {
             type: "content",
-            content: { type: "text", text: input.prompt }
+            content: { type: "text", text: String(input.prompt) }
           }
         ] : []
       };
     case "NotebookRead":
       return {
-        title: input?.notebook_path ? `Read Notebook ${input.notebook_path}` : "Read Notebook",
+        title: input?.notebook_path ? `Read Notebook ${String(input.notebook_path)}` : "Read Notebook",
         kind: "read",
         content: [],
-        locations: input?.notebook_path ? [{ path: input.notebook_path }] : []
+        locations: input?.notebook_path ? [{ path: String(input.notebook_path) }] : []
       };
     case "NotebookEdit":
       return {
-        title: input?.notebook_path ? `Edit Notebook ${input.notebook_path}` : "Edit Notebook",
+        title: input?.notebook_path ? `Edit Notebook ${String(input.notebook_path)}` : "Edit Notebook",
         kind: "edit",
         content: input?.new_source ? [
           {
             type: "content",
-            content: { type: "text", text: input.new_source }
+            content: { type: "text", text: String(input.new_source) }
           }
         ] : [],
-        locations: input?.notebook_path ? [{ path: input.notebook_path }] : []
+        locations: input?.notebook_path ? [{ path: String(input.notebook_path) }] : []
       };
     case "Bash":
     case toolNames.bash:
       return {
-        title: input?.command ? `\`${input.command.replaceAll("`", "\\`")}\`` : "Terminal",
+        title: input?.command ? `\`${String(input.command).replaceAll("`", "\\`")}\`` : "Terminal",
         kind: "execute",
         content: input?.description ? [
           {
             type: "content",
-            content: { type: "text", text: input.description }
+            content: { type: "text", text: String(input.description) }
           }
         ] : []
       };
@@ -1136,18 +1127,20 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger2 = new Logger({
       };
     case toolNames.read: {
       let limit = "";
-      if (input.limit) {
-        limit = " (" + ((input.offset ?? 0) + 1) + " - " + ((input.offset ?? 0) + input.limit) + ")";
-      } else if (input.offset) {
-        limit = ` (from line ${input.offset + 1})`;
+      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 ?? "File"}${limit}`,
+        title: `Read ${input?.file_path ? String(input.file_path) : "File"}${limit}`,
         kind: "read",
-        locations: input.file_path ? [
+        locations: input?.file_path ? [
           {
-            path: input.file_path,
-            line: input.offset ?? 0
+            path: String(input.file_path),
+            line: inputOffset
           }
         ] : [],
         content: []
@@ -1158,25 +1151,25 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger2 = new Logger({
         title: "Read File",
         kind: "read",
         content: [],
-        locations: input.file_path ? [
+        locations: input?.file_path ? [
           {
-            path: input.file_path,
-            line: input.offset ?? 0
+            path: String(input.file_path),
+            line: input?.offset ?? 0
           }
         ] : []
       };
     case "LS":
       return {
-        title: `List the ${input?.path ? `\`${input.path}\`` : "current"} directory's contents`,
+        title: `List the ${input?.path ? `\`${String(input.path)}\`` : "current"} directory's contents`,
         kind: "search",
         content: [],
         locations: []
       };
     case toolNames.edit:
     case "Edit": {
-      const path3 = input?.file_path ?? input?.file_path;
-      let oldText = input.old_string ?? null;
-      let newText = input.new_string ?? "";
+      const path3 = 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 (path3 && oldText) {
         try {
@@ -1192,7 +1185,7 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger2 = new Logger({
           newText = newContent.newContent;
           affectedLines = newContent.lineNumbers;
         } catch (e) {
-          logger2.error("Failed to edit file", e);
+          logger.error("Failed to edit file", e);
         }
       }
       return {
@@ -1210,78 +1203,84 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger2 = new Logger({
       };
     }
     case toolNames.write: {
-      let content = [];
-      if (input?.file_path) {
-        content = [
+      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 = [
           {
             type: "diff",
-            path: input.file_path,
+            path: filePath,
             oldText: null,
-            newText: input.content
+            newText: contentStr ?? ""
           }
         ];
-      } else if (input?.content) {
-        content = [
+      } else if (contentStr) {
+        contentResult = [
           {
             type: "content",
-            content: { type: "text", text: input.content }
+            content: { type: "text", text: contentStr }
           }
         ];
       }
       return {
-        title: input?.file_path ? `Write ${input.file_path}` : "Write",
+        title: filePath ? `Write ${filePath}` : "Write",
         kind: "edit",
-        content,
-        locations: input?.file_path ? [{ path: input.file_path }] : []
+        content: contentResult,
+        locations: filePath ? [{ path: filePath }] : []
       };
     }
-    case "Write":
+    case "Write": {
+      const filePath = input?.file_path ? String(input.file_path) : void 0;
+      const contentStr = input?.content ? String(input.content) : "";
       return {
-        title: input?.file_path ? `Write ${input.file_path}` : "Write",
+        title: filePath ? `Write ${filePath}` : "Write",
         kind: "edit",
-        content: input?.file_path ? [
+        content: filePath ? [
           {
             type: "diff",
-            path: input.file_path,
+            path: filePath,
             oldText: null,
-            newText: input.content
+            newText: contentStr
           }
         ] : [],
-        locations: input?.file_path ? [{ path: input.file_path }] : []
+        locations: filePath ? [{ path: filePath }] : []
       };
+    }
     case "Glob": {
       let label = "Find";
-      if (input.path) {
-        label += ` \`${input.path}\``;
+      const pathStr = input?.path ? String(input.path) : void 0;
+      if (pathStr) {
+        label += ` \`${pathStr}\``;
       }
-      if (input.pattern) {
-        label += ` \`${input.pattern}\``;
+      if (input?.pattern) {
+        label += ` \`${String(input.pattern)}\``;
       }
       return {
         title: label,
         kind: "search",
         content: [],
-        locations: input.path ? [{ path: input.path }] : []
+        locations: pathStr ? [{ path: pathStr }] : []
       };
     }
     case "Grep": {
       let label = "grep";
-      if (input["-i"]) {
+      if (input?.["-i"]) {
         label += " -i";
       }
-      if (input["-n"]) {
+      if (input?.["-n"]) {
         label += " -n";
       }
-      if (input["-A"] !== void 0) {
+      if (input?.["-A"] !== void 0) {
         label += ` -A ${input["-A"]}`;
       }
-      if (input["-B"] !== void 0) {
+      if (input?.["-B"] !== void 0) {
         label += ` -B ${input["-B"]}`;
       }
-      if (input["-C"] !== void 0) {
+      if (input?.["-C"] !== void 0) {
         label += ` -C ${input["-C"]}`;
       }
-      if (input.output_mode) {
+      if (input?.output_mode) {
         switch (input.output_mode) {
           case "FilesWithMatches":
             label += " -l";
@@ -1293,21 +1292,21 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger2 = new Logger({
             break;
         }
       }
-      if (input.head_limit !== void 0) {
+      if (input?.head_limit !== void 0) {
         label += ` | head -${input.head_limit}`;
       }
-      if (input.glob) {
-        label += ` --include="${input.glob}"`;
+      if (input?.glob) {
+        label += ` --include="${String(input.glob)}"`;
       }
-      if (input.type) {
-        label += ` --type=${input.type}`;
+      if (input?.type) {
+        label += ` --type=${String(input.type)}`;
       }
-      if (input.multiline) {
+      if (input?.multiline) {
         label += " -P";
       }
-      label += ` "${input.pattern}"`;
-      if (input.path) {
-        label += ` ${input.path}`;
+      label += ` "${input?.pattern ? String(input.pattern) : ""}"`;
+      if (input?.path) {
+        label += ` ${String(input.path)}`;
       }
       return {
         title: label,
@@ -1317,22 +1316,24 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger2 = new Logger({
     }
     case "WebFetch":
       return {
-        title: input?.url ? `Fetch ${input.url}` : "Fetch",
+        title: input?.url ? `Fetch ${String(input.url)}` : "Fetch",
         kind: "fetch",
         content: input?.prompt ? [
           {
             type: "content",
-            content: { type: "text", text: input.prompt }
+            content: { type: "text", text: String(input.prompt) }
           }
         ] : []
       };
     case "WebSearch": {
-      let label = `"${input.query}"`;
-      if (input.allowed_domains && input.allowed_domains.length > 0) {
-        label += ` (allowed: ${input.allowed_domains.join(", ")})`;
+      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 (input.blocked_domains && input.blocked_domains.length > 0) {
-        label += ` (blocked: ${input.blocked_domains.join(", ")})`;
+      if (blockedDomains && blockedDomains.length > 0) {
+        label += ` (blocked: ${blockedDomains.join(", ")})`;
       }
       return {
         title: label,
@@ -1350,8 +1351,29 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger2 = new Logger({
       return {
         title: "Ready to code?",
         kind: "switch_mode",
-        content: input?.plan ? [{ type: "content", content: { type: "text", text: input.plan } }] : []
+        content: input?.plan ? [
+          {
+            type: "content",
+            content: { type: "text", text: String(input.plan) }
+          }
+        ] : []
+      };
+    case "AskUserQuestion": {
+      const questions = input?.questions;
+      return {
+        title: questions?.[0]?.question || "Question",
+        kind: "ask",
+        content: questions ? [
+          {
+            type: "content",
+            content: {
+              type: "text",
+              text: JSON.stringify(questions, null, 2)
+            }
+          }
+        ] : []
       };
+    }
     case "Other": {
       let output;
       try {
@@ -1388,15 +1410,24 @@ function toolUpdateFromToolResult(toolResult, toolUse) {
     case toolNames.read:
       if (Array.isArray(toolResult.content) && toolResult.content.length > 0) {
         return {
-          content: toolResult.content.map((content) => ({
-            type: "content",
-            content: content.type === "text" ? {
-              type: "text",
-              text: markdownEscape(
-                content.text.replace(SYSTEM_REMINDER, "")
-              )
-            } : content
-          }))
+          content: toolResult.content.map((item) => {
+            const itemObj = item;
+            if (itemObj.type === "text") {
+              return {
+                type: "content",
+                content: {
+                  type: "text",
+                  text: markdownEscape(
+                    (itemObj.text ?? "").replace(SYSTEM_REMINDER, "")
+                  )
+                }
+              };
+            }
+            return {
+              type: "content",
+              content: item
+            };
+          })
         };
       } else if (typeof toolResult.content === "string" && toolResult.content.length > 0) {
         return {
@@ -1428,6 +1459,24 @@ function toolUpdateFromToolResult(toolResult, toolUse) {
     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: [
+              {
+                type: "content",
+                content: { type: "text", text: String(firstItem.text) }
+              }
+            ]
+          };
+        }
+      }
+      return { title: "Question answered" };
+    }
     default: {
       return toAcpContentUpdate(
         toolResult.content,
@@ -1439,15 +1488,24 @@ function toolUpdateFromToolResult(toolResult, toolUse) {
 function toAcpContentUpdate(content, isError = false) {
   if (Array.isArray(content) && content.length > 0) {
     return {
-      content: content.map((content2) => ({
-        type: "content",
-        content: isError && content2.type === "text" ? {
-          ...content2,
-          text: `\`\`\`
-${content2.text}
+      content: content.map((item) => {
+        const itemObj = item;
+        if (isError && itemObj.type === "text") {
+          return {
+            type: "content",
+            content: {
+              type: "text",
+              text: `\`\`\`
+${itemObj.text ?? ""}
 \`\`\``
-        } : content2
-      }))
+            }
+          };
+        }
+        return {
+          type: "content",
+          content: item
+        };
+      })
     };
   } else if (typeof content === "string" && content.length > 0) {
     return {
@@ -1491,7 +1549,7 @@ var registerHookCallback = (toolUseID, {
     onPostToolUseHook
   };
 };
-var createPostToolUseHook = (logger2 = new Logger({ prefix: "[createPostToolUseHook]" })) => async (input, toolUseID) => {
+var createPostToolUseHook = (logger = new Logger({ prefix: "[createPostToolUseHook]" })) => async (input, toolUseID) => {
   if (input.hook_event_name === "PostToolUse" && toolUseID) {
     const onPostToolUseHook = toolUseCallbacks[toolUseID]?.onPostToolUseHook;
     if (onPostToolUseHook) {
@@ -1502,7 +1560,7 @@ var createPostToolUseHook = (logger2 = new Logger({ prefix: "[createPostToolUseH
       );
       delete toolUseCallbacks[toolUseID];
     } else {
-      logger2.error(
+      logger.error(
         `No onPostToolUseHook found for tool use ID: ${toolUseID}`
       );
       delete toolUseCallbacks[toolUseID];
@@ -1512,9 +1570,115 @@ var createPostToolUseHook = (logger2 = new Logger({ prefix: "[createPostToolUseH
 };
 
 // src/adapters/claude/claude.ts
+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);
+}
+var READ_ONLY_COMMAND_PREFIXES = [
+  // File listing and info
+  "ls",
+  "find",
+  "tree",
+  "stat",
+  "file",
+  "wc",
+  "du",
+  "df",
+  // File reading (non-modifying)
+  "cat",
+  "head",
+  "tail",
+  "less",
+  "more",
+  "bat",
+  // Search
+  "grep",
+  "rg",
+  "ag",
+  "ack",
+  "fzf",
+  // Git read operations
+  "git status",
+  "git log",
+  "git diff",
+  "git show",
+  "git branch",
+  "git remote",
+  "git fetch",
+  "git rev-parse",
+  "git ls-files",
+  "git blame",
+  "git shortlog",
+  "git describe",
+  "git tag -l",
+  "git tag --list",
+  // System info
+  "pwd",
+  "whoami",
+  "which",
+  "where",
+  "type",
+  "printenv",
+  "env",
+  "echo",
+  "printf",
+  "date",
+  "uptime",
+  "uname",
+  "id",
+  "groups",
+  // Process info
+  "ps",
+  "top",
+  "htop",
+  "pgrep",
+  "lsof",
+  // Network read-only
+  "curl",
+  "wget",
+  "ping",
+  "host",
+  "dig",
+  "nslookup",
+  // Package managers (info only)
+  "npm list",
+  "npm ls",
+  "npm view",
+  "npm info",
+  "npm outdated",
+  "pnpm list",
+  "pnpm ls",
+  "pnpm why",
+  "yarn list",
+  "yarn why",
+  "yarn info",
+  // Other read-only
+  "jq",
+  "yq",
+  "xargs",
+  "sort",
+  "uniq",
+  "tr",
+  "cut",
+  "awk",
+  "sed -n"
+];
+function isReadOnlyBashCommand(command) {
+  const trimmed = command.trim();
+  return READ_ONLY_COMMAND_PREFIXES.some(
+    (prefix) => trimmed === prefix || trimmed.startsWith(`${prefix} `) || trimmed.startsWith(`${prefix}	`)
+  );
+}
 function clearStatsigCache() {
-  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
-  const statsigPath = path.join(configDir, "statsig");
+  const statsigPath = path.join(getClaudeConfigDir(), "statsig");
   try {
     if (fs.existsSync(statsigPath)) {
       fs.rmSync(statsigPath, { recursive: true, force: true });
@@ -1550,6 +1714,33 @@ var ClaudeAcpAgent = class {
     this.sessions[sessionId] = session;
     return session;
   }
+  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("");
+  }
+  isPlanReady(plan) {
+    if (!plan) return false;
+    const trimmed = plan.trim();
+    if (trimmed.length < 40) return false;
+    return /(^|\n)#{1,6}\s+\S/.test(trimmed);
+  }
   appendNotification(sessionId, notification) {
     this.sessions[sessionId]?.notificationHistory.push(notification);
   }
@@ -1631,7 +1822,9 @@ var ClaudeAcpAgent = class {
         systemPrompt.append = customPrompt.append;
       }
     }
-    const permissionMode = "default";
+    const initialModeId = params._meta?.initialModeId;
+    const ourPermissionMode = initialModeId ?? "default";
+    const sdkPermissionMode = ourPermissionMode;
     const userProvidedOptions = params._meta?.claudeCode?.options;
     const options = {
       systemPrompt,
@@ -1645,7 +1838,8 @@ var ClaudeAcpAgent = class {
       // If we want bypassPermissions to be an option, we have to allow it here.
       // But it doesn't work in root mode, so we only activate it if it will work.
       allowDangerouslySkipPermissions: !IS_ROOT,
-      permissionMode,
+      // Use the requested permission mode (including plan mode)
+      permissionMode: sdkPermissionMode,
       canUseTool: this.canUseTool(sessionId),
       // Use "node" to resolve via PATH where a symlink to Electron exists.
       // This avoids launching the Electron binary directly from the app bundle,
@@ -1653,7 +1847,12 @@ var ClaudeAcpAgent = class {
       executable: "node",
       // Prevent spawned Electron processes from showing in dock/tray.
       // Must merge with process.env since SDK replaces rather than merges.
-      env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" },
+      // Enable AskUserQuestion tool via environment variable (required by SDK feature flag)
+      env: {
+        ...process.env,
+        ELECTRON_RUN_AS_NODE: "1",
+        CLAUDE_CODE_ENABLE_ASK_USER_QUESTION_TOOL: "true"
+      },
       ...process.env.CLAUDE_CODE_EXECUTABLE && {
         pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE
       },
@@ -1667,7 +1866,7 @@ var ClaudeAcpAgent = class {
         ]
       }
     };
-    const allowedTools = [];
+    const allowedTools = ["AskUserQuestion"];
     const disallowedTools = [];
     const disableBuiltInTools = params._meta?.disableBuiltInTools === true;
     if (!disableBuiltInTools) {
@@ -1709,6 +1908,9 @@ var ClaudeAcpAgent = class {
         "NotebookEdit"
       );
     }
+    if (ourPermissionMode !== "plan") {
+      disallowedTools.push("ExitPlanMode");
+    }
     if (allowedTools.length > 0) {
       options.allowedTools = allowedTools;
     }
@@ -1724,7 +1926,7 @@ var ClaudeAcpAgent = class {
       prompt: input,
       options
     });
-    this.createSession(sessionId, q, input, permissionMode);
+    this.createSession(sessionId, q, input, ourPermissionMode);
     const persistence = params._meta?.persistence;
     if (persistence && this.sessionStore) {
       this.sessionStore.register(sessionId, persistence);
@@ -1780,7 +1982,7 @@ var ClaudeAcpAgent = class {
       sessionId,
       models,
       modes: {
-        currentModeId: permissionMode,
+        currentModeId: ourPermissionMode,
         availableModes
       }
     };
@@ -1793,7 +1995,8 @@ var ClaudeAcpAgent = class {
       throw new Error("Session not found");
     }
     this.sessions[params.sessionId].cancelled = false;
-    const { query: query5, input } = this.sessions[params.sessionId];
+    const session = this.sessions[params.sessionId];
+    const { query: query2, input } = session;
     for (const chunk of params.prompt) {
       const userNotification = {
         sessionId: params.sessionId,
@@ -1805,9 +2008,9 @@ var ClaudeAcpAgent = class {
       await this.client.sessionUpdate(userNotification);
       this.appendNotification(params.sessionId, userNotification);
     }
-    input.push(promptToClaude(params));
+    input.push(promptToClaude({ ...params, prompt: params.prompt }));
     while (true) {
-      const { value: message, done } = await query5.next();
+      const { value: message, done } = await query2.next();
       if (done || !message) {
         if (this.sessions[params.sessionId].cancelled) {
           return { stopReason: "cancelled" };
@@ -1823,9 +2026,9 @@ var ClaudeAcpAgent = class {
           switch (message.subtype) {
             case "init":
               if (message.session_id) {
-                const session = this.sessions[params.sessionId];
-                if (session && !session.sdkSessionId) {
-                  session.sdkSessionId = message.session_id;
+                const session2 = this.sessions[params.sessionId];
+                if (session2 && !session2.sdkSessionId) {
+                  session2.sdkSessionId = message.session_id;
                   this.client.extNotification("_posthog/sdk_session", {
                     sessionId: params.sessionId,
                     sdkSessionId: message.session_id
@@ -2008,7 +2211,64 @@ var ClaudeAcpAgent = class {
           interrupt: true
         };
       }
+      const emitToolDenial = async (message) => {
+        this.logger.info(`[canUseTool] Tool denied: ${toolName}`, { message });
+        await this.client.sessionUpdate({
+          sessionId,
+          update: {
+            sessionUpdate: "tool_call_update",
+            toolCallId: toolUseID,
+            status: "failed",
+            content: [
+              {
+                type: "content",
+                content: {
+                  type: "text",
+                  text: message
+                }
+              }
+            ]
+          }
+        });
+      };
       if (toolName === "ExitPlanMode") {
+        if (session.permissionMode !== "plan") {
+          return {
+            behavior: "allow",
+            updatedInput: toolInput
+          };
+        }
+        let updatedInput = toolInput;
+        const planFromFile = session.lastPlanContent || (session.lastPlanFilePath ? this.fileContentCache[session.lastPlanFilePath] : void 0);
+        const hasPlan = typeof toolInput?.plan === "string";
+        if (!hasPlan) {
+          const fallbackPlan = planFromFile ? planFromFile : this.getLatestAssistantText(session.notificationHistory);
+          if (fallbackPlan) {
+            updatedInput = {
+              ...toolInput,
+              plan: fallbackPlan
+            };
+          }
+        }
+        const planText = typeof updatedInput?.plan === "string" ? String(updatedInput.plan) : void 0;
+        if (!planText) {
+          const message = `Plan not ready. Provide the full markdown plan in ExitPlanMode or write it to ${getClaudePlansDir()} before requesting approval.`;
+          await emitToolDenial(message);
+          return {
+            behavior: "deny",
+            message,
+            interrupt: false
+          };
+        }
+        if (!this.isPlanReady(planText)) {
+          const message = "Plan not ready. Provide the full markdown plan in ExitPlanMode before requesting approval.";
+          await emitToolDenial(message);
+          return {
+            behavior: "deny",
+            message,
+            interrupt: false
+          };
+        }
         const response2 = await this.client.requestPermission({
           options: [
             {
@@ -2030,9 +2290,9 @@ var ClaudeAcpAgent = class {
           sessionId,
           toolCall: {
             toolCallId: toolUseID,
-            rawInput: toolInput,
+            rawInput: { ...updatedInput, toolName },
             title: toolInfoFromToolUse(
-              { name: toolName, input: toolInput },
+              { name: toolName, input: updatedInput },
               this.fileContentCache,
               this.logger
             ).title
@@ -2049,7 +2309,7 @@ var ClaudeAcpAgent = class {
           });
           return {
             behavior: "allow",
-            updatedInput: toolInput,
+            updatedInput,
             updatedPermissions: suggestions ?? [
               {
                 type: "setMode",
@@ -2058,13 +2318,147 @@ var ClaudeAcpAgent = class {
               }
             ]
           };
+        } else {
+          const message = "User wants to continue planning. Please refine your plan based on any feedback provided, or ask clarifying questions if needed.";
+          await emitToolDenial(message);
+          return {
+            behavior: "deny",
+            message,
+            interrupt: false
+          };
+        }
+      }
+      if (toolName === "AskUserQuestion") {
+        const input = toolInput;
+        let questions;
+        if (input.questions && input.questions.length > 0) {
+          questions = input.questions;
+        } else if (input.question) {
+          questions = [
+            {
+              question: input.question,
+              header: input.header,
+              options: input.options || [],
+              multiSelect: input.multiSelect
+            }
+          ];
         } else {
           return {
             behavior: "deny",
-            message: "User rejected request to exit plan mode.",
+            message: "No questions provided",
             interrupt: true
           };
         }
+        const allAnswers = {};
+        for (let i = 0; i < questions.length; i++) {
+          const question = questions[i];
+          const options = (question.options || []).map(
+            (opt, idx) => ({
+              kind: "allow_once",
+              name: opt.label,
+              optionId: `option_${idx}`,
+              description: opt.description
+            })
+          );
+          options.push({
+            kind: "allow_once",
+            name: "Other",
+            optionId: "other",
+            description: "Provide a custom response"
+          });
+          const response2 = await this.client.requestPermission({
+            options,
+            sessionId,
+            toolCall: {
+              toolCallId: toolUseID,
+              rawInput: {
+                ...toolInput,
+                toolName,
+                // Include full question data for UI rendering
+                currentQuestion: question,
+                questionIndex: i,
+                totalQuestions: questions.length
+              },
+              // Use the full question text as title for the selection input
+              title: question.question
+            }
+          });
+          if (response2.outcome?.outcome === "selected") {
+            const selectedOptionId = response2.outcome.optionId;
+            const extendedOutcome = response2.outcome;
+            if (selectedOptionId === "other" && extendedOutcome.customInput) {
+              allAnswers[question.question] = extendedOutcome.customInput;
+            } else if (selectedOptionId === "other") {
+              allAnswers[question.question] = "other";
+            } else if (question.multiSelect && extendedOutcome.selectedOptionIds) {
+              const selectedLabels = extendedOutcome.selectedOptionIds.map((id) => {
+                const idx = parseInt(id.replace("option_", ""), 10);
+                return question.options?.[idx]?.label;
+              }).filter(Boolean);
+              allAnswers[question.question] = selectedLabels;
+            } else {
+              const selectedIdx = parseInt(
+                selectedOptionId.replace("option_", ""),
+                10
+              );
+              const selectedOption = question.options?.[selectedIdx];
+              allAnswers[question.question] = selectedOption?.label || selectedOptionId;
+            }
+          } else {
+            return {
+              behavior: "deny",
+              message: "User did not complete all questions",
+              interrupt: true
+            };
+          }
+        }
+        return {
+          behavior: "allow",
+          updatedInput: {
+            ...toolInput,
+            answers: allAnswers
+          }
+        };
+      }
+      const WRITE_TOOL_NAMES = [
+        ...EDIT_TOOL_NAMES,
+        "Edit",
+        "Write",
+        "NotebookEdit"
+      ];
+      if (session.permissionMode === "plan" && WRITE_TOOL_NAMES.includes(toolName)) {
+        const filePath = toolInput?.file_path;
+        const isPlanFile = isClaudePlanFilePath(filePath);
+        if (isPlanFile) {
+          session.lastPlanFilePath = filePath;
+          const content = toolInput?.content;
+          if (typeof content === "string") {
+            session.lastPlanContent = content;
+          }
+          return {
+            behavior: "allow",
+            updatedInput: toolInput
+          };
+        }
+        const message = "Cannot use write tools in plan mode. Use ExitPlanMode to request permission to make changes.";
+        await emitToolDenial(message);
+        return {
+          behavior: "deny",
+          message,
+          interrupt: false
+        };
+      }
+      if (session.permissionMode === "plan" && (toolName === "Bash" || toolName === toolNames.bash)) {
+        const command = toolInput?.command ?? "";
+        if (!isReadOnlyBashCommand(command)) {
+          const message = "Cannot run write/modify bash commands in plan mode. Use ExitPlanMode to request permission to make changes.";
+          await emitToolDenial(message);
+          return {
+            behavior: "deny",
+            message,
+            interrupt: false
+          };
+        }
       }
       if (session.permissionMode === "bypassPermissions" || session.permissionMode === "acceptEdits" && EDIT_TOOL_NAMES.includes(toolName)) {
         return {
@@ -2121,9 +2515,11 @@ var ClaudeAcpAgent = class {
           updatedInput: toolInput
         };
       } else {
+        const message = "User refused permission to run tool";
+        await emitToolDenial(message);
         return {
           behavior: "deny",
-          message: "User refused permission to run tool",
+          message,
           interrupt: true
         };
       }
@@ -2143,6 +2539,11 @@ var ClaudeAcpAgent = class {
       await this.setSessionModel({ sessionId, modelId });
       return {};
     }
+    if (method === "session/setMode") {
+      const { sessionId, modeId } = params;
+      await this.setSessionMode({ sessionId, modeId });
+      return {};
+    }
     throw RequestError.methodNotFound(method);
   }
   /**
@@ -2252,10 +2653,10 @@ var ClaudeAcpAgent = class {
     return {};
   }
 };
-async function getAvailableModels(query5) {
-  const models = await query5.supportedModels();
+async function getAvailableModels(query2) {
+  const models = await query2.supportedModels();
   const currentModel = models[0];
-  await query5.setModel(currentModel.value);
+  await query2.setModel(currentModel.value);
   const availableModels = models.map((model) => ({
     modelId: model.value,
     name: model.displayName,
@@ -2266,7 +2667,7 @@ async function getAvailableModels(query5) {
     currentModelId: currentModel.value
   };
 }
-async function getAvailableSlashCommands(query5) {
+async function getAvailableSlashCommands(query2) {
   const UNSUPPORTED_COMMANDS = [
     "context",
     "cost",
@@ -2276,7 +2677,7 @@ async function getAvailableSlashCommands(query5) {
     "release-notes",
     "todos"
   ];
-  const commands = await query5.supportedCommands();
+  const commands = await query2.supportedCommands();
   return commands.map((command) => {
     const input = command.argumentHint ? { hint: command.argumentHint } : null;
     let name = command.name;
@@ -2384,7 +2785,7 @@ ${chunk.resource.text}
     parent_tool_use_id: null
   };
 }
-function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentCache, client, logger2) {
+function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentCache, client, logger) {
   if (typeof content === "string") {
     return [
       {
@@ -2465,7 +2866,7 @@ function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentC
                   update: update2
                 });
               } else {
-                logger2.error(
+                logger.error(
                   `[claude-code-acp] Got a tool response for tool use that wasn't tracked: ${toolUseId}`
                 );
               }
@@ -2486,7 +2887,7 @@ function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentC
             sessionUpdate: "tool_call",
             rawInput,
             status: "pending",
-            ...toolInfoFromToolUse(chunk, fileContentCache, logger2)
+            ...toolInfoFromToolUse(chunk, fileContentCache, logger)
           };
         }
         break;
@@ -2501,7 +2902,7 @@ function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentC
       case "mcp_tool_result": {
         const toolUse = toolUseCache[chunk.tool_use_id];
         if (!toolUse) {
-          logger2.error(
+          logger.error(
             `[claude-code-acp] Got a tool result for tool use that wasn't tracked: ${chunk.tool_use_id}`
           );
           break;
@@ -2530,7 +2931,7 @@ function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentC
       case "container_upload":
         break;
       default:
-        unreachable(chunk, logger2);
+        unreachable(chunk, logger);
         break;
     }
     if (update) {
@@ -2539,7 +2940,7 @@ function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentC
   }
   return output;
 }
-function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileContentCache, client, logger2) {
+function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileContentCache, client, logger) {
   const event = message.event;
   switch (event.type) {
     case "content_block_start":
@@ -2550,7 +2951,7 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileCon
         toolUseCache,
         fileContentCache,
         client,
-        logger2
+        logger
       );
     case "content_block_delta":
       return toAcpNotifications(
@@ -2560,7 +2961,7 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileCon
         toolUseCache,
         fileContentCache,
         client,
-        logger2
+        logger
       );
     // No content
     case "message_start":
@@ -2569,14 +2970,16 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileCon
     case "content_block_stop":
       return [];
     default:
-      unreachable(event, logger2);
+      unreachable(event, logger);
       return [];
   }
 }
+
+// src/adapters/connection.ts
 function createAcpConnection(config = {}) {
-  const logger2 = new Logger({ debug: true, prefix: "[AcpConnection]" });
+  const logger = new Logger({ debug: true, prefix: "[AcpConnection]" });
   const streams = createBidirectionalStreams();
-  const { sessionStore } = config;
+  const { sessionStore, framework = "claude" } = config;
   let agentWritable = streams.agent.writable;
   let clientWritable = streams.client.writable;
   if (config.sessionId && sessionStore) {
@@ -2592,25 +2995,25 @@ function createAcpConnection(config = {}) {
       onMessage: (line) => {
         sessionStore.appendRawLine(config.sessionId, line);
       },
-      logger: logger2
+      logger
     });
     clientWritable = createTappedWritableStream(streams.client.writable, {
       onMessage: (line) => {
         sessionStore.appendRawLine(config.sessionId, line);
       },
-      logger: logger2
+      logger
     });
   } else {
-    logger2.info("Tapped streams NOT enabled", {
+    logger.info("Tapped streams NOT enabled", {
       hasSessionId: !!config.sessionId,
       hasSessionStore: !!sessionStore
     });
   }
   const agentStream = ndJsonStream(agentWritable, streams.agent.readable);
-  const agentConnection = new AgentSideConnection(
-    (client) => new ClaudeAcpAgent(client, sessionStore),
-    agentStream
-  );
+  const agentConnection = new AgentSideConnection((client) => {
+    logger.info("Creating Claude agent");
+    return new ClaudeAcpAgent(client, sessionStore);
+  }, agentStream);
   return {
     agentConnection,
     clientStreams: {
@@ -2634,9 +3037,9 @@ import z2 from "zod";
 var PostHogFileManager = class {
   repositoryPath;
   logger;
-  constructor(repositoryPath, logger2) {
+  constructor(repositoryPath, logger) {
     this.repositoryPath = repositoryPath;
-    this.logger = logger2 || new Logger({ debug: false, prefix: "[FileManager]" });
+    this.logger = logger || new Logger({ debug: false, prefix: "[FileManager]" });
   }
   getTaskDirectory(taskId) {
     return join2(this.repositoryPath, ".posthog", taskId);
@@ -2752,35 +3155,6 @@ var PostHogFileManager = class {
   async readRequirements(taskId) {
     return await this.readTaskFile(taskId, "requirements.md");
   }
-  async writeResearch(taskId, data) {
-    this.logger.debug("Writing research", {
-      taskId,
-      score: data.actionabilityScore,
-      hasQuestions: !!data.questions,
-      questionCount: data.questions?.length ?? 0,
-      answered: data.answered ?? false
-    });
-    await this.writeTaskFile(taskId, {
-      name: "research.json",
-      content: JSON.stringify(data, null, 2),
-      type: "artifact"
-    });
-    this.logger.info("Research file written", {
-      taskId,
-      score: data.actionabilityScore,
-      hasQuestions: !!data.questions,
-      answered: data.answered ?? false
-    });
-  }
-  async readResearch(taskId) {
-    try {
-      const content = await this.readTaskFile(taskId, "research.json");
-      return content ? JSON.parse(content) : null;
-    } catch (error) {
-      this.logger.debug("Failed to parse research.json", { error });
-      return null;
-    }
-  }
   async writeTodos(taskId, data) {
     const todos = z2.object({
       metadata: z2.object({
@@ -3588,489 +3962,71 @@ ${errorData.stack_trace}
   }
 };
 
-// src/prompt-builder.ts
-import { promises as fs3 } from "fs";
-import { join as join3 } from "path";
-var PromptBuilder = class {
-  getTaskFiles;
-  generatePlanTemplate;
-  posthogClient;
+// src/session-store.ts
+var SessionStore = class {
+  posthogAPI;
+  pendingEntries = /* @__PURE__ */ new Map();
+  flushTimeouts = /* @__PURE__ */ new Map();
+  configs = /* @__PURE__ */ new Map();
   logger;
-  constructor(deps) {
-    this.getTaskFiles = deps.getTaskFiles;
-    this.generatePlanTemplate = deps.generatePlanTemplate;
-    this.posthogClient = deps.posthogClient;
-    this.logger = deps.logger || new Logger({ debug: false, prefix: "[PromptBuilder]" });
+  constructor(posthogAPI, logger) {
+    this.posthogAPI = posthogAPI;
+    this.logger = logger ?? new Logger({ debug: false, prefix: "[SessionStore]" });
+    const flushAllAndExit = async () => {
+      const flushPromises = [];
+      for (const sessionId of this.configs.keys()) {
+        flushPromises.push(this.flush(sessionId));
+      }
+      await Promise.all(flushPromises);
+      process.exit(0);
+    };
+    process.on("beforeExit", () => {
+      flushAllAndExit().catch((e) => this.logger.error("Flush failed:", e));
+    });
+    process.on("SIGINT", () => {
+      flushAllAndExit().catch((e) => this.logger.error("Flush failed:", e));
+    });
+    process.on("SIGTERM", () => {
+      flushAllAndExit().catch((e) => this.logger.error("Flush failed:", e));
+    });
   }
-  /**
-   * Extract file paths from XML tags in description
-   * Format: <file path="relative/path.ts" />
-   */
-  extractFilePaths(description) {
-    const fileTagRegex = /<file\s+path="([^"]+)"\s*\/>/g;
-    const paths = [];
-    let match;
-    match = fileTagRegex.exec(description);
-    while (match !== null) {
-      paths.push(match[1]);
-      match = fileTagRegex.exec(description);
-    }
-    return paths;
+  /** Register a session for persistence */
+  register(sessionId, config) {
+    this.configs.set(sessionId, config);
   }
-  /**
-   * Read file contents from repository
-   */
-  async readFileContent(repositoryPath, filePath) {
-    try {
-      const fullPath = join3(repositoryPath, filePath);
-      const content = await fs3.readFile(fullPath, "utf8");
-      return content;
-    } catch (error) {
-      this.logger.warn(`Failed to read referenced file: ${filePath}`, {
-        error
-      });
-      return null;
-    }
+  /** Unregister and flush pending */
+  async unregister(sessionId) {
+    await this.flush(sessionId);
+    this.configs.delete(sessionId);
+  }
+  /** Check if a session is registered for persistence */
+  isRegistered(sessionId) {
+    return this.configs.has(sessionId);
   }
   /**
-   * Extract URL mentions from XML tags in description
-   * Formats: <error id="..." />, <experiment id="..." />, <url href="..." />
+   * Append a raw JSON-RPC line for persistence.
+   * Parses and wraps as StoredNotification for the API.
    */
-  extractUrlMentions(description) {
-    const mentions = [];
-    const resourceRegex = /<(error|experiment|insight|feature_flag)\s+id="([^"]+)"\s*\/>/g;
-    let match;
-    match = resourceRegex.exec(description);
-    while (match !== null) {
-      const [, type, id] = match;
-      mentions.push({
-        url: "",
-        // Will be reconstructed if needed
-        type,
-        id,
-        label: this.generateUrlLabel("", type)
-      });
-      match = resourceRegex.exec(description);
-    }
-    const urlRegex = /<url\s+href="([^"]+)"\s*\/>/g;
-    match = urlRegex.exec(description);
-    while (match !== null) {
-      const [, url] = match;
-      mentions.push({
-        url,
-        type: "generic",
-        label: this.generateUrlLabel(url, "generic")
-      });
-      match = urlRegex.exec(description);
-    }
-    return mentions;
-  }
-  /**
-   * Generate a display label for a URL mention
-   */
-  generateUrlLabel(url, type) {
-    try {
-      const urlObj = new URL(url);
-      switch (type) {
-        case "error": {
-          const errorMatch = url.match(/error_tracking\/([a-f0-9-]+)/);
-          return errorMatch ? `Error ${errorMatch[1].slice(0, 8)}...` : "Error";
-        }
-        case "experiment": {
-          const expMatch = url.match(/experiments\/(\d+)/);
-          return expMatch ? `Experiment #${expMatch[1]}` : "Experiment";
-        }
-        case "insight":
-          return "Insight";
-        case "feature_flag":
-          return "Feature Flag";
-        default:
-          return urlObj.hostname;
-      }
-    } catch {
-      return "URL";
-    }
-  }
-  /**
-   * Process URL references and fetch their content
-   */
-  async processUrlReferences(description) {
-    const urlMentions = this.extractUrlMentions(description);
-    const referencedResources = [];
-    if (urlMentions.length === 0 || !this.posthogClient) {
-      return { description, referencedResources };
-    }
-    for (const mention of urlMentions) {
-      try {
-        const resource = await this.posthogClient.fetchResourceByUrl(mention);
-        referencedResources.push(resource);
-      } catch (error) {
-        this.logger.warn(`Failed to fetch resource from URL: ${mention.url}`, {
-          error
-        });
-        referencedResources.push({
-          type: mention.type,
-          id: mention.id || "",
-          url: mention.url,
-          title: mention.label || "Unknown Resource",
-          content: `Failed to fetch resource from ${mention.url}: ${error}`,
-          metadata: {}
-        });
-      }
-    }
-    let processedDescription = description;
-    for (const mention of urlMentions) {
-      if (mention.type === "generic") {
-        const escapedUrl = mention.url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        processedDescription = processedDescription.replace(
-          new RegExp(`<url\\s+href="${escapedUrl}"\\s*/>`, "g"),
-          `@${mention.label}`
-        );
-      } else {
-        const escapedType = mention.type.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const escapedId = mention.id ? mention.id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : "";
-        processedDescription = processedDescription.replace(
-          new RegExp(`<${escapedType}\\s+id="${escapedId}"\\s*/>`, "g"),
-          `@${mention.label}`
-        );
-      }
-    }
-    return { description: processedDescription, referencedResources };
-  }
-  /**
-   * Process description to extract file tags and read contents
-   * Returns processed description and referenced file contents
-   */
-  async processFileReferences(description, repositoryPath) {
-    const filePaths = this.extractFilePaths(description);
-    const referencedFiles = [];
-    if (filePaths.length === 0 || !repositoryPath) {
-      return { description, referencedFiles };
-    }
-    const successfulPaths = /* @__PURE__ */ new Set();
-    for (const filePath of filePaths) {
-      const content = await this.readFileContent(repositoryPath, filePath);
-      if (content !== null) {
-        referencedFiles.push({ path: filePath, content });
-        successfulPaths.add(filePath);
-      }
-    }
-    let processedDescription = description;
-    for (const filePath of successfulPaths) {
-      const fileName = filePath.split("/").pop() || filePath;
-      processedDescription = processedDescription.replace(
-        new RegExp(
-          `<file\\s+path="${filePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}"\\s*/>`,
-          "g"
-        ),
-        `@${fileName}`
-      );
-    }
-    return { description: processedDescription, referencedFiles };
-  }
-  async buildResearchPrompt(task, repositoryPath) {
-    const { description: descriptionAfterFiles, referencedFiles } = await this.processFileReferences(task.description, repositoryPath);
-    const { description: processedDescription, referencedResources } = await this.processUrlReferences(descriptionAfterFiles);
-    let prompt = "<task>\n";
-    prompt += `<title>${task.title}</title>
-`;
-    prompt += `<description>${processedDescription}</description>
-`;
-    if (task.repository) {
-      prompt += `<repository>${task.repository}</repository>
-`;
-    }
-    prompt += "</task>\n";
-    if (referencedFiles.length > 0) {
-      prompt += "\n<referenced_files>\n";
-      for (const file of referencedFiles) {
-        prompt += `<file path="${file.path}">
-\`\`\`
-${file.content}
-\`\`\`
-</file>
-`;
-      }
-      prompt += "</referenced_files>\n";
-    }
-    if (referencedResources.length > 0) {
-      prompt += "\n<referenced_resources>\n";
-      for (const resource of referencedResources) {
-        prompt += `<resource type="${resource.type}" url="${resource.url}">
-`;
-        prompt += `<title>${resource.title}</title>
-`;
-        prompt += `<content>${resource.content}</content>
-`;
-        prompt += "</resource>\n";
-      }
-      prompt += "</referenced_resources>\n";
-    }
-    try {
-      const taskFiles = await this.getTaskFiles(task.id);
-      const contextFiles = taskFiles.filter(
-        (f) => f.type === "context" || f.type === "reference"
-      );
-      if (contextFiles.length > 0) {
-        prompt += "\n<supporting_files>\n";
-        for (const file of contextFiles) {
-          prompt += `<file name="${file.name}" type="${file.type}">
-${file.content}
-</file>
-`;
-        }
-        prompt += "</supporting_files>\n";
-      }
-    } catch (_error) {
-      this.logger.debug("No existing task files found for research", {
-        taskId: task.id
-      });
-    }
-    return prompt;
-  }
-  async buildPlanningPrompt(task, repositoryPath) {
-    const { description: descriptionAfterFiles, referencedFiles } = await this.processFileReferences(task.description, repositoryPath);
-    const { description: processedDescription, referencedResources } = await this.processUrlReferences(descriptionAfterFiles);
-    let prompt = "<task>\n";
-    prompt += `<title>${task.title}</title>
-`;
-    prompt += `<description>${processedDescription}</description>
-`;
-    if (task.repository) {
-      prompt += `<repository>${task.repository}</repository>
-`;
-    }
-    prompt += "</task>\n";
-    if (referencedFiles.length > 0) {
-      prompt += "\n<referenced_files>\n";
-      for (const file of referencedFiles) {
-        prompt += `<file path="${file.path}">
-\`\`\`
-${file.content}
-\`\`\`
-</file>
-`;
-      }
-      prompt += "</referenced_files>\n";
-    }
-    if (referencedResources.length > 0) {
-      prompt += "\n<referenced_resources>\n";
-      for (const resource of referencedResources) {
-        prompt += `<resource type="${resource.type}" url="${resource.url}">
-`;
-        prompt += `<title>${resource.title}</title>
-`;
-        prompt += `<content>${resource.content}</content>
-`;
-        prompt += "</resource>\n";
-      }
-      prompt += "</referenced_resources>\n";
-    }
-    try {
-      const taskFiles = await this.getTaskFiles(task.id);
-      const contextFiles = taskFiles.filter(
-        (f) => f.type === "context" || f.type === "reference"
-      );
-      if (contextFiles.length > 0) {
-        prompt += "\n<supporting_files>\n";
-        for (const file of contextFiles) {
-          prompt += `<file name="${file.name}" type="${file.type}">
-${file.content}
-</file>
-`;
-        }
-        prompt += "</supporting_files>\n";
-      }
-    } catch (_error) {
-      this.logger.debug("No existing task files found for planning", {
-        taskId: task.id
-      });
-    }
-    const templateVariables = {
-      task_id: task.id,
-      task_title: task.title,
-      task_description: processedDescription,
-      date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-      repository: task.repository || ""
-    };
-    const planTemplate = await this.generatePlanTemplate(templateVariables);
-    prompt += "\n<instructions>\n";
-    prompt += "Analyze the codebase and create a detailed implementation plan. Use the template structure below, filling each section with specific, actionable information.\n";
-    prompt += "</instructions>\n\n";
-    prompt += "<plan_template>\n";
-    prompt += planTemplate;
-    prompt += "\n</plan_template>";
-    return prompt;
-  }
-  async buildExecutionPrompt(task, repositoryPath) {
-    const { description: descriptionAfterFiles, referencedFiles } = await this.processFileReferences(task.description, repositoryPath);
-    const { description: processedDescription, referencedResources } = await this.processUrlReferences(descriptionAfterFiles);
-    let prompt = "<task>\n";
-    prompt += `<title>${task.title}</title>
-`;
-    prompt += `<description>${processedDescription}</description>
-`;
-    if (task.repository) {
-      prompt += `<repository>${task.repository}</repository>
-`;
-    }
-    prompt += "</task>\n";
-    if (referencedFiles.length > 0) {
-      prompt += "\n<referenced_files>\n";
-      for (const file of referencedFiles) {
-        prompt += `<file path="${file.path}">
-\`\`\`
-${file.content}
-\`\`\`
-</file>
-`;
-      }
-      prompt += "</referenced_files>\n";
-    }
-    if (referencedResources.length > 0) {
-      prompt += "\n<referenced_resources>\n";
-      for (const resource of referencedResources) {
-        prompt += `<resource type="${resource.type}" url="${resource.url}">
-`;
-        prompt += `<title>${resource.title}</title>
-`;
-        prompt += `<content>${resource.content}</content>
-`;
-        prompt += "</resource>\n";
-      }
-      prompt += "</referenced_resources>\n";
-    }
-    try {
-      const taskFiles = await this.getTaskFiles(task.id);
-      const hasPlan = taskFiles.some((f) => f.type === "plan");
-      const todosFile = taskFiles.find(
-        (f) => f.name === "todos.json"
-      );
-      if (taskFiles.length > 0) {
-        prompt += "\n<context>\n";
-        for (const file of taskFiles) {
-          if (file.type === "plan") {
-            prompt += `<plan>
-${file.content}
-</plan>
-`;
-          } else if (file.name === "todos.json") {
-          } else {
-            prompt += `<file name="${file.name}" type="${file.type}">
-${file.content}
-</file>
-`;
-          }
-        }
-        prompt += "</context>\n";
-      }
-      if (todosFile) {
-        try {
-          const todos = JSON.parse(todosFile.content);
-          if (todos.items && todos.items.length > 0) {
-            prompt += "\n<previous_todos>\n";
-            prompt += "You previously created the following todo list for this task:\n\n";
-            for (const item of todos.items) {
-              const statusIcon = item.status === "completed" ? "\u2713" : item.status === "in_progress" ? "\u25B6" : "\u25CB";
-              prompt += `${statusIcon} [${item.status}] ${item.content}
-`;
-            }
-            prompt += `
-Progress: ${todos.metadata.completed}/${todos.metadata.total} completed
-`;
-            prompt += "\nYou can reference this list when resuming work or create an updated list as needed.\n";
-            prompt += "</previous_todos>\n";
-          }
-        } catch (error) {
-          this.logger.debug("Failed to parse todos.json for context", {
-            error
-          });
-        }
-      }
-      prompt += "\n<instructions>\n";
-      if (hasPlan) {
-        prompt += "Implement the changes described in the execution plan. Follow the plan step-by-step and make the necessary file modifications.\n";
-      } else {
-        prompt += "Implement the changes described in the task. Make the necessary file modifications to complete the task.\n";
-      }
-      prompt += "</instructions>";
-    } catch (_error) {
-      this.logger.debug("No supporting files found for execution", {
-        taskId: task.id
-      });
-      prompt += "\n<instructions>\n";
-      prompt += "Implement the changes described in the task.\n";
-      prompt += "</instructions>";
-    }
-    return prompt;
-  }
-};
-
-// src/session-store.ts
-var SessionStore = class {
-  posthogAPI;
-  pendingEntries = /* @__PURE__ */ new Map();
-  flushTimeouts = /* @__PURE__ */ new Map();
-  configs = /* @__PURE__ */ new Map();
-  logger;
-  constructor(posthogAPI, logger2) {
-    this.posthogAPI = posthogAPI;
-    this.logger = logger2 ?? new Logger({ debug: false, prefix: "[SessionStore]" });
-    const flushAllAndExit = async () => {
-      const flushPromises = [];
-      for (const sessionId of this.configs.keys()) {
-        flushPromises.push(this.flush(sessionId));
-      }
-      await Promise.all(flushPromises);
-      process.exit(0);
-    };
-    process.on("beforeExit", () => {
-      flushAllAndExit().catch((e) => this.logger.error("Flush failed:", e));
-    });
-    process.on("SIGINT", () => {
-      flushAllAndExit().catch((e) => this.logger.error("Flush failed:", e));
-    });
-    process.on("SIGTERM", () => {
-      flushAllAndExit().catch((e) => this.logger.error("Flush failed:", e));
-    });
-  }
-  /** Register a session for persistence */
-  register(sessionId, config) {
-    this.configs.set(sessionId, config);
-  }
-  /** Unregister and flush pending */
-  async unregister(sessionId) {
-    await this.flush(sessionId);
-    this.configs.delete(sessionId);
-  }
-  /** Check if a session is registered for persistence */
-  isRegistered(sessionId) {
-    return this.configs.has(sessionId);
-  }
-  /**
-   * Append a raw JSON-RPC line for persistence.
-   * Parses and wraps as StoredNotification for the API.
-   */
-  appendRawLine(sessionId, line) {
-    const config = this.configs.get(sessionId);
-    if (!config) {
-      return;
-    }
-    try {
-      const message = JSON.parse(line);
-      const entry = {
-        type: "notification",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        notification: message
-      };
-      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
+  appendRawLine(sessionId, line) {
+    const config = this.configs.get(sessionId);
+    if (!config) {
+      return;
+    }
+    try {
+      const message = JSON.parse(line);
+      const entry = {
+        type: "notification",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        notification: message
+      };
+      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
       });
     }
   }
@@ -4303,1333 +4259,38 @@ var TaskManager = class {
   }
   scheduleTimeout(executionId, timeout = this.defaultTimeout) {
     setTimeout(() => {
-      const execution = this.executionStates.get(executionId);
-      if (execution && execution.status === "running") {
-        execution.status = "timeout";
-        execution.completedAt = Date.now();
-        execution.abortController?.abort();
-        if (!execution.result) {
-          execution.result = {
-            status: "timeout",
-            message: "Execution timed out"
-          };
-        }
-      }
-    }, timeout);
-  }
-  cleanup(olderThan = 60 * 60 * 1e3) {
-    const cutoff = Date.now() - olderThan;
-    for (const [executionId, execution] of this.executionStates) {
-      if (execution.completedAt && execution.completedAt < cutoff) {
-        this.executionStates.delete(executionId);
-      }
-    }
-  }
-};
-
-// src/template-manager.ts
-import { existsSync as existsSync2, promises as fs4 } from "fs";
-import { dirname, join as join4 } from "path";
-import { fileURLToPath } from "url";
-var logger = new Logger({ prefix: "[TemplateManager]" });
-var TemplateManager = class {
-  templatesDir;
-  constructor() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const candidateDirs = [
-      // Standard build output (dist/src/template-manager.js -> dist/templates)
-      join4(__dirname, "..", "templates"),
-      // If preserveModules creates nested structure (dist/src/template-manager.js -> dist/src/templates)
-      join4(__dirname, "templates"),
-      // Development scenarios (src/template-manager.ts -> src/templates)
-      join4(__dirname, "..", "..", "src", "templates"),
-      // Package root templates directory
-      join4(__dirname, "..", "..", "templates"),
-      // When node_modules symlink or installed (node_modules/@posthog/agent/dist/src/... -> node_modules/@posthog/agent/dist/templates)
-      join4(__dirname, "..", "..", "dist", "templates"),
-      // When consumed from node_modules deep in tree
-      join4(__dirname, "..", "..", "..", "templates"),
-      join4(__dirname, "..", "..", "..", "dist", "templates"),
-      join4(__dirname, "..", "..", "..", "src", "templates"),
-      // When bundled by Vite/Webpack (e.g., .vite/build/index.js -> node_modules/@posthog/agent/dist/templates)
-      // Try to find node_modules from current location
-      join4(
-        __dirname,
-        "..",
-        "node_modules",
-        "@posthog",
-        "agent",
-        "dist",
-        "templates"
-      ),
-      join4(
-        __dirname,
-        "..",
-        "..",
-        "node_modules",
-        "@posthog",
-        "agent",
-        "dist",
-        "templates"
-      ),
-      join4(
-        __dirname,
-        "..",
-        "..",
-        "..",
-        "node_modules",
-        "@posthog",
-        "agent",
-        "dist",
-        "templates"
-      )
-    ];
-    const resolvedDir = candidateDirs.find((dir) => existsSync2(dir));
-    if (!resolvedDir) {
-      logger.error("Could not find templates directory.");
-      logger.error(`Current file: ${__filename}`);
-      logger.error(`Current dir: ${__dirname}`);
-      logger.error(
-        `Tried: ${candidateDirs.map((d) => `
-  - ${d} (exists: ${existsSync2(d)})`).join("")}`
-      );
-    }
-    this.templatesDir = resolvedDir ?? candidateDirs[0];
-  }
-  async loadTemplate(templateName) {
-    try {
-      const templatePath = join4(this.templatesDir, templateName);
-      return await fs4.readFile(templatePath, "utf8");
-    } catch (error) {
-      throw new Error(
-        `Failed to load template ${templateName} from ${this.templatesDir}: ${error}`
-      );
-    }
-  }
-  substituteVariables(template, variables) {
-    let result = template;
-    for (const [key, value] of Object.entries(variables)) {
-      if (value !== void 0) {
-        const placeholder = new RegExp(`{{${key}}}`, "g");
-        result = result.replace(placeholder, value);
-      }
-    }
-    result = result.replace(/{{[^}]+}}/g, "[PLACEHOLDER]");
-    return result;
-  }
-  async generatePlan(variables) {
-    const template = await this.loadTemplate("plan-template.md");
-    return this.substituteVariables(template, {
-      ...variables,
-      date: variables.date || (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
-    });
-  }
-  async generateCustomFile(templateName, variables) {
-    const template = await this.loadTemplate(templateName);
-    return this.substituteVariables(template, {
-      ...variables,
-      date: variables.date || (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
-    });
-  }
-  async createTaskStructure(taskId, taskTitle, options) {
-    const files = [];
-    const variables = {
-      task_id: taskId,
-      task_title: taskTitle,
-      date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
-    };
-    if (options?.includePlan !== false) {
-      const planContent = await this.generatePlan(variables);
-      files.push({
-        name: "plan.md",
-        content: planContent,
-        type: "plan"
-      });
-    }
-    if (options?.additionalFiles) {
-      for (const file of options.additionalFiles) {
-        let content;
-        if (file.template) {
-          content = await this.generateCustomFile(file.template, variables);
-        } else if (file.content) {
-          content = this.substituteVariables(file.content, variables);
-        } else {
-          content = `# ${file.name}
-
-Placeholder content for ${file.name}`;
-        }
-        files.push({
-          name: file.name,
-          content,
-          type: file.name.includes("context") ? "context" : "reference"
-        });
-      }
-    }
-    return files;
-  }
-  generatePostHogReadme() {
-    return `# PostHog Task Files
-
-This directory contains task-related files.
-
-## Structure
-
-Each task has its own subdirectory: \`.posthog/{task-id}/\`
-
-### Common Files
-
-- **plan.md** - Implementation plan generated during planning phase
-- **Supporting files** - Any additional files added for task context
-- **artifacts/** - Generated files, outputs, and temporary artifacts
-
-### Usage
-
-These files are:
-- Version controlled alongside your code
-- Used for task context and planning
-- Available for review in pull requests
-- Organized by task ID for easy reference
-
-### Gitignore
-
-Customize \`.posthog/.gitignore\` to control which files are committed:
-- Include plans and documentation by default
-- Exclude temporary files and sensitive data
-- Customize based on your team's needs
-`;
-  }
-};
-
-// src/workflow/steps/build.ts
-import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
-
-// src/agents/execution.ts
-var EXECUTION_SYSTEM_PROMPT = `<role>
-PostHog AI Execution Agent \u2014 autonomously implement tasks as merge-ready code following project conventions.
-</role>
-
-<context>
-You have access to local repository files and PostHog MCP server. Work primarily with local files for implementation. Commit changes regularly.
-</context>
-
-<constraints>
-- Follow existing code style, patterns, and conventions found in the repository
-- Minimize new external dependencies \u2014 only add when necessary
-- Implement structured logging and error handling (never log secrets)
-- Avoid destructive shell commands
-- Create/update .gitignore to exclude build artifacts, dependencies, and temp files
-</constraints>
-
-<approach>
-1. Review the implementation plan if provided, or create your own todo list
-2. Execute changes step by step
-3. Test thoroughly and verify functionality
-4. Commit changes with clear messages
-</approach>
-
-<checklist>
-Before completing the task, verify:
-- .gitignore includes build artifacts, node_modules, __pycache__, etc.
-- Dependency files (package.json, requirements.txt) use exact versions
-- Code compiles and tests pass
-- Added or updated relevant tests
-- Captured meaningful events with PostHog SDK where appropriate
-- Wrapped new logic in PostHog feature flags where appropriate
-- Updated documentation, README, or type hints as needed
-</checklist>
-
-<output_format>
-Provide a concise summary of changes made when finished.
-</output_format>`;
-
-// src/todo-manager.ts
-var TodoManager = class {
-  fileManager;
-  logger;
-  constructor(fileManager, logger2) {
-    this.fileManager = fileManager;
-    this.logger = logger2 || new Logger({ debug: false, prefix: "[TodoManager]" });
-  }
-  async readTodos(taskId) {
-    try {
-      const content = await this.fileManager.readTaskFile(taskId, "todos.json");
-      if (!content) {
-        return null;
-      }
-      const parsed = JSON.parse(content);
-      this.logger.debug("Loaded todos", {
-        taskId,
-        total: parsed.metadata.total,
-        pending: parsed.metadata.pending,
-        in_progress: parsed.metadata.in_progress,
-        completed: parsed.metadata.completed
-      });
-      return parsed;
-    } catch (error) {
-      this.logger.debug("Failed to read todos.json", {
-        taskId,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return null;
-    }
-  }
-  async writeTodos(taskId, todos) {
-    this.logger.debug("Writing todos", {
-      taskId,
-      total: todos.metadata.total,
-      pending: todos.metadata.pending,
-      in_progress: todos.metadata.in_progress,
-      completed: todos.metadata.completed
-    });
-    await this.fileManager.writeTaskFile(taskId, {
-      name: "todos.json",
-      content: JSON.stringify(todos, null, 2),
-      type: "artifact"
-    });
-    this.logger.info("Todos saved", {
-      taskId,
-      total: todos.metadata.total,
-      completed: todos.metadata.completed
-    });
-  }
-  parseTodoWriteInput(toolInput) {
-    const items = [];
-    if (toolInput.todos && Array.isArray(toolInput.todos)) {
-      for (const todo of toolInput.todos) {
-        items.push({
-          content: todo.content || "",
-          status: todo.status || "pending",
-          activeForm: todo.activeForm || todo.content || ""
-        });
-      }
-    }
-    const metadata = this.calculateMetadata(items);
-    return { items, metadata };
-  }
-  calculateMetadata(items) {
-    const total = items.length;
-    const pending = items.filter((t) => t.status === "pending").length;
-    const in_progress = items.filter((t) => t.status === "in_progress").length;
-    const completed = items.filter((t) => t.status === "completed").length;
-    return {
-      total,
-      pending,
-      in_progress,
-      completed,
-      last_updated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  async getTodoContext(taskId) {
-    const todos = await this.readTodos(taskId);
-    if (!todos || todos.items.length === 0) {
-      return "";
-    }
-    const lines = ["## Previous Todo List\n"];
-    lines.push("You previously created the following todo list:\n");
-    for (const item of todos.items) {
-      const statusIcon = item.status === "completed" ? "\u2713" : item.status === "in_progress" ? "\u25B6" : "\u25CB";
-      lines.push(`${statusIcon} [${item.status}] ${item.content}`);
-    }
-    lines.push(
-      `
-Progress: ${todos.metadata.completed}/${todos.metadata.total} completed
-`
-    );
-    return lines.join("\n");
-  }
-  // check for TodoWrite tool call and persist if found
-  async checkAndPersistFromMessage(message, taskId) {
-    if (message.type !== "assistant" || typeof message.message !== "object" || !message.message || !("content" in message.message) || !Array.isArray(message.message.content)) {
-      return null;
-    }
-    for (const block of message.message.content) {
-      if (block.type === "tool_use" && block.name === "TodoWrite") {
-        try {
-          this.logger.info("TodoWrite detected, persisting todos", { taskId });
-          const todoList = this.parseTodoWriteInput(block.input);
-          await this.writeTodos(taskId, todoList);
-          this.logger.info("Persisted todos successfully", {
-            taskId,
-            total: todoList.metadata.total,
-            completed: todoList.metadata.completed
-          });
-          return todoList;
-        } catch (error) {
-          this.logger.error("Failed to persist todos", {
-            taskId,
-            error: error instanceof Error ? error.message : String(error)
-          });
-          return null;
-        }
-      }
-    }
-    return null;
-  }
-};
-
-// src/types.ts
-var PermissionMode = /* @__PURE__ */ ((PermissionMode2) => {
-  PermissionMode2["PLAN"] = "plan";
-  PermissionMode2["DEFAULT"] = "default";
-  PermissionMode2["ACCEPT_EDITS"] = "acceptEdits";
-  PermissionMode2["BYPASS"] = "bypassPermissions";
-  return PermissionMode2;
-})(PermissionMode || {});
-
-// src/workflow/steps/build.ts
-var buildStep = async ({ step, context }) => {
-  const {
-    task,
-    cwd,
-    options,
-    logger: logger2,
-    promptBuilder,
-    sessionId,
-    mcpServers,
-    gitManager,
-    sendNotification
-  } = context;
-  const stepLogger = logger2.child("BuildStep");
-  const latestRun = task.latest_run;
-  const prExists = latestRun?.output && typeof latestRun.output === "object" ? latestRun.output.pr_url : null;
-  if (prExists) {
-    stepLogger.info("PR already exists, skipping build phase", {
-      taskId: task.id
-    });
-    return { status: "skipped" };
-  }
-  stepLogger.info("Starting build phase", { taskId: task.id });
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_START, {
-    sessionId,
-    phase: "build"
-  });
-  const executionPrompt = await promptBuilder.buildExecutionPrompt(task, cwd);
-  const fullPrompt = `${EXECUTION_SYSTEM_PROMPT}
-
-${executionPrompt}`;
-  const configuredPermissionMode = options.permissionMode ?? (typeof step.permissionMode === "string" ? step.permissionMode : step.permissionMode) ?? "acceptEdits" /* ACCEPT_EDITS */;
-  const baseOptions = {
-    model: step.model,
-    cwd,
-    permissionMode: configuredPermissionMode,
-    settingSources: ["local"],
-    mcpServers,
-    // Allow all tools for build phase - full read/write access needed for implementation
-    allowedTools: [
-      "Task",
-      "Bash",
-      "BashOutput",
-      "KillBash",
-      "Edit",
-      "Read",
-      "Write",
-      "Glob",
-      "Grep",
-      "NotebookEdit",
-      "WebFetch",
-      "WebSearch",
-      "ListMcpResources",
-      "ReadMcpResource",
-      "TodoWrite"
-    ]
-  };
-  if (options.canUseTool) {
-    baseOptions.canUseTool = options.canUseTool;
-  }
-  const response = query2({
-    prompt: fullPrompt,
-    options: { ...baseOptions, ...options.queryOverrides || {} }
-  });
-  const commitTracker = await gitManager.trackCommitsDuring();
-  const todoManager = new TodoManager(context.fileManager, stepLogger);
-  try {
-    for await (const message of response) {
-      const todoList = await todoManager.checkAndPersistFromMessage(
-        message,
-        task.id
-      );
-      if (todoList) {
-        await sendNotification(POSTHOG_NOTIFICATIONS.ARTIFACT, {
-          sessionId,
-          kind: "todos",
-          content: todoList
-        });
-      }
-    }
-  } catch (error) {
-    stepLogger.error("Error during build step query", error);
-    throw error;
-  }
-  const { commitCreated, pushedBranch } = await commitTracker.finalize({
-    commitMessage: `Implementation for ${task.title}`,
-    push: step.push
-  });
-  context.stepResults[step.id] = { commitCreated };
-  if (!commitCreated) {
-    stepLogger.warn("No changes to commit in build phase", { taskId: task.id });
-  } else {
-    stepLogger.info("Build commits finalized", {
-      taskId: task.id,
-      pushedBranch
-    });
-  }
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-    sessionId,
-    phase: "build"
-  });
-  return { status: "completed" };
-};
-
-// src/workflow/utils.ts
-async function finalizeStepGitActions(context, step, options) {
-  if (!step.commit) {
-    return false;
-  }
-  const { gitManager, logger: logger2 } = context;
-  const hasStagedChanges = await gitManager.hasStagedChanges();
-  if (!hasStagedChanges && !options.allowEmptyCommit) {
-    logger2.debug("No staged changes to commit for step", { stepId: step.id });
-    return false;
-  }
-  try {
-    await gitManager.commitChanges(options.commitMessage);
-    logger2.info("Committed changes for step", {
-      stepId: step.id,
-      message: options.commitMessage
-    });
-  } catch (error) {
-    logger2.error("Failed to commit changes for step", {
-      stepId: step.id,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    throw error;
-  }
-  if (step.push) {
-    const branchName = await gitManager.getCurrentBranch();
-    await gitManager.pushBranch(branchName);
-    logger2.info("Pushed branch after step", {
-      stepId: step.id,
-      branch: branchName
-    });
-  }
-  return true;
-}
-
-// src/workflow/steps/finalize.ts
-var MAX_SNIPPET_LENGTH = 1200;
-var finalizeStep = async ({ step, context }) => {
-  const { task, logger: logger2, fileManager, gitManager, posthogAPI, runId } = context;
-  const stepLogger = logger2.child("FinalizeStep");
-  const artifacts = await fileManager.collectTaskArtifacts(task.id);
-  let uploadedArtifacts;
-  if (artifacts.length && posthogAPI && runId) {
-    try {
-      const payload = artifacts.map((artifact) => ({
-        name: artifact.name,
-        type: artifact.type,
-        content: artifact.content,
-        content_type: artifact.contentType
-      }));
-      uploadedArtifacts = await posthogAPI.uploadTaskArtifacts(
-        task.id,
-        runId,
-        payload
-      );
-      stepLogger.info("Uploaded task artifacts to PostHog", {
-        taskId: task.id,
-        uploadedCount: uploadedArtifacts.length
-      });
-    } catch (error) {
-      stepLogger.warn("Failed to upload task artifacts", {
-        taskId: task.id,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  } else {
-    stepLogger.debug("Skipping artifact upload", {
-      hasArtifacts: artifacts.length > 0,
-      hasPostHogApi: Boolean(posthogAPI),
-      runId
-    });
-  }
-  const prBody = buildPullRequestBody(task, artifacts, uploadedArtifacts);
-  await fileManager.cleanupTaskDirectory(task.id);
-  await gitManager.addAllPostHogFiles();
-  await finalizeStepGitActions(context, step, {
-    commitMessage: `Cleanup task artifacts for ${task.title}`,
-    allowEmptyCommit: true
-  });
-  context.stepResults[step.id] = {
-    prBody,
-    uploadedArtifacts,
-    artifactCount: artifacts.length
-  };
-  return { status: "completed" };
-};
-function buildPullRequestBody(task, artifacts, uploaded) {
-  const lines = [];
-  const taskSlug = task.slug || task.id;
-  lines.push("## Task context");
-  lines.push(`- **Task**: ${taskSlug}`);
-  lines.push(`- **Title**: ${task.title}`);
-  lines.push(`- **Origin**: ${task.origin_product}`);
-  if (task.description) {
-    lines.push("");
-    lines.push(`> ${task.description.trim().split("\n").join("\n> ")}`);
-  }
-  const usedFiles = /* @__PURE__ */ new Set();
-  const contextArtifact = artifacts.find(
-    (artifact) => artifact.name === "context.md"
-  );
-  if (contextArtifact) {
-    lines.push("");
-    lines.push("### Task prompt");
-    lines.push(contextArtifact.content);
-    usedFiles.add(contextArtifact.name);
-  }
-  const researchArtifact = artifacts.find(
-    (artifact) => artifact.name === "research.json"
-  );
-  if (researchArtifact) {
-    usedFiles.add(researchArtifact.name);
-    const researchSection = formatResearchSection(researchArtifact.content);
-    if (researchSection) {
-      lines.push("");
-      lines.push(researchSection);
-    }
-  }
-  const planArtifact = artifacts.find(
-    (artifact) => artifact.name === "plan.md"
-  );
-  if (planArtifact) {
-    lines.push("");
-    lines.push("### Implementation plan");
-    lines.push(planArtifact.content);
-    usedFiles.add(planArtifact.name);
-  }
-  const todoArtifact = artifacts.find(
-    (artifact) => artifact.name === "todos.json"
-  );
-  if (todoArtifact) {
-    const summary = summarizeTodos(todoArtifact.content);
-    if (summary) {
-      lines.push("");
-      lines.push("### Todo list");
-      lines.push(summary);
-    }
-    usedFiles.add(todoArtifact.name);
-  }
-  const remainingArtifacts = artifacts.filter(
-    (artifact) => !usedFiles.has(artifact.name)
-  );
-  if (remainingArtifacts.length) {
-    lines.push("");
-    lines.push("### Additional artifacts");
-    for (const artifact of remainingArtifacts) {
-      lines.push(`#### ${artifact.name}`);
-      lines.push(renderCodeFence(artifact.content));
-    }
-  }
-  const artifactList = uploaded ?? artifacts.map((artifact) => ({
-    name: artifact.name,
-    type: artifact.type
-  }));
-  if (artifactList.length) {
-    lines.push("");
-    lines.push("### Uploaded artifacts");
-    for (const artifact of artifactList) {
-      const rawStoragePath = "storage_path" in artifact ? artifact.storage_path : void 0;
-      const storagePath = typeof rawStoragePath === "string" ? rawStoragePath : void 0;
-      const storage = storagePath && storagePath.trim().length > 0 ? ` \u2013 \`${storagePath.trim()}\`` : "";
-      lines.push(`- ${artifact.name} (${artifact.type})${storage}`);
-    }
-  }
-  return lines.join("\n\n");
-}
-function renderCodeFence(content) {
-  const snippet = truncate(content, MAX_SNIPPET_LENGTH);
-  return ["```", snippet, "```"].join("\n");
-}
-function truncate(value, maxLength) {
-  if (value.length <= maxLength) {
-    return value;
-  }
-  return `${value.slice(0, maxLength)}
-\u2026`;
-}
-function formatResearchSection(content) {
-  try {
-    const parsed = JSON.parse(content);
-    const sections = [];
-    if (parsed.context) {
-      sections.push("### Research summary");
-      sections.push(parsed.context);
-    }
-    if (parsed.questions?.length) {
-      sections.push("");
-      sections.push("### Questions needing answers");
-      for (const question of parsed.questions) {
-        sections.push(`- ${question.question ?? question}`);
-      }
-    }
-    if (parsed.answers?.length) {
-      sections.push("");
-      sections.push("### Answers provided");
-      for (const answer of parsed.answers) {
-        const questionId = answer.questionId ? ` (Q: ${answer.questionId})` : "";
-        sections.push(
-          `- ${answer.selectedOption || answer.customInput || "answer"}${questionId}`
-        );
-      }
-    }
-    return sections.length ? sections.join("\n") : null;
-  } catch {
-    return null;
-  }
-}
-function summarizeTodos(content) {
-  try {
-    const data = JSON.parse(content);
-    const total = data?.metadata?.total ?? data?.items?.length;
-    const completed = data?.metadata?.completed ?? data?.items?.filter(
-      (item) => item.status === "completed"
-    ).length;
-    const lines = [`Progress: ${completed}/${total} completed`];
-    if (data?.items?.length) {
-      for (const item of data.items) {
-        lines.push(`- [${item.status}] ${item.content}`);
-      }
-    }
-    return lines.join("\n");
-  } catch {
-    return null;
-  }
-}
-
-// src/workflow/steps/plan.ts
-import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
-
-// src/agents/planning.ts
-var PLANNING_SYSTEM_PROMPT = `<role>
-PostHog AI Planning Agent \u2014 analyze codebases and create actionable implementation plans.
-</role>
-
-<constraints>
-- Read-only: analyze files, search code, explore structure
-- No modifications or edits
-- Output ONLY the plan markdown \u2014 no preamble, no acknowledgment, no meta-commentary
-</constraints>
-
-<objective>
-Create a detailed, actionable implementation plan that an execution agent can follow to complete the task successfully.
-</objective>
-
-<process>
-1. Explore repository structure and identify relevant files/components
-2. Understand existing patterns, conventions, and dependencies
-3. Break down task requirements and identify technical constraints
-4. Define step-by-step implementation approach
-5. Specify files to modify/create with exact paths
-6. Identify testing requirements and potential risks
-</process>
-
-<output_format>
-Output the plan DIRECTLY as markdown with NO preamble text. Do NOT say "I'll create a plan" or "Here's the plan" \u2014 just output the plan content.
-
-Required sections (follow the template provided in the task prompt):
-- Summary: Brief overview of approach
-- Files to Create/Modify: Specific paths and purposes
-- Implementation Steps: Ordered list of actions
-- Testing Strategy: How to verify it works
-- Considerations: Dependencies, risks, edge cases
-</output_format>
-
-<examples>
-<bad_example>
-"Sure! I'll create a detailed implementation plan for you to add authentication. Here's what we'll do..."
-Reason: No preamble \u2014 output the plan directly
-</bad_example>
-
-<good_example>
-"# Implementation Plan
-
-## Summary
-Add JWT-based authentication to API endpoints using existing middleware pattern...
-
-## Files to Modify
-- src/middleware/auth.ts: Add JWT verification
-..."
-Reason: Direct plan output with no meta-commentary
-</good_example>
-</examples>
-
-<context_integration>
-If research findings, context files, or reference materials are provided:
-- Incorporate research findings into your analysis
-- Follow patterns and approaches identified in research
-- Build upon or refine any existing planning work
-- Reference specific files and components mentioned in context
-</context_integration>`;
-
-// src/workflow/steps/plan.ts
-var planStep = async ({ step, context }) => {
-  const {
-    task,
-    cwd,
-    isCloudMode,
-    options,
-    logger: logger2,
-    fileManager,
-    gitManager,
-    promptBuilder,
-    sessionId,
-    mcpServers,
-    sendNotification
-  } = context;
-  const stepLogger = logger2.child("PlanStep");
-  const existingPlan = await fileManager.readPlan(task.id);
-  if (existingPlan) {
-    stepLogger.info("Plan already exists, skipping step", { taskId: task.id });
-    return { status: "skipped" };
-  }
-  const researchData = await fileManager.readResearch(task.id);
-  if (researchData?.questions && !researchData.answered) {
-    stepLogger.info("Waiting for answered research questions", {
-      taskId: task.id
-    });
-    await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-      sessionId,
-      phase: "research_questions"
-    });
-    return { status: "skipped", halt: true };
-  }
-  stepLogger.info("Starting planning phase", { taskId: task.id });
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_START, {
-    sessionId,
-    phase: "planning"
-  });
-  let researchContext = "";
-  if (researchData) {
-    researchContext += `## Research Context
-
-${researchData.context}
-
-`;
-    if (researchData.keyFiles.length > 0) {
-      researchContext += `**Key Files:**
-${researchData.keyFiles.map((f) => `- ${f}`).join("\n")}
-
-`;
-    }
-    if (researchData.blockers && researchData.blockers.length > 0) {
-      researchContext += `**Considerations:**
-${researchData.blockers.map((b) => `- ${b}`).join("\n")}
-
-`;
-    }
-    if (researchData.questions && researchData.answers && researchData.answered) {
-      researchContext += `## Implementation Decisions
-
-`;
-      for (const question of researchData.questions) {
-        const answer = researchData.answers.find(
-          (a) => a.questionId === question.id
-        );
-        researchContext += `### ${question.question}
-
-`;
-        if (answer) {
-          researchContext += `**Selected:** ${answer.selectedOption}
-`;
-          if (answer.customInput) {
-            researchContext += `**Details:** ${answer.customInput}
-`;
-          }
-        } else {
-          researchContext += `**Selected:** Not answered
-`;
-        }
-        researchContext += `
-`;
-      }
-    }
-  }
-  const planningPrompt = await promptBuilder.buildPlanningPrompt(task, cwd);
-  const fullPrompt = `${PLANNING_SYSTEM_PROMPT}
-
-${planningPrompt}
-
-${researchContext}`;
-  const baseOptions = {
-    model: step.model,
-    cwd,
-    permissionMode: "plan",
-    settingSources: ["local"],
-    mcpServers,
-    // Allow research tools: read-only operations, web search, MCP resources, and ExitPlanMode
-    allowedTools: [
-      "Read",
-      "Glob",
-      "Grep",
-      "WebFetch",
-      "WebSearch",
-      "ListMcpResources",
-      "ReadMcpResource",
-      "ExitPlanMode",
-      "TodoWrite",
-      "BashOutput"
-    ]
-  };
-  const response = query3({
-    prompt: fullPrompt,
-    options: { ...baseOptions, ...options.queryOverrides || {} }
-  });
-  const todoManager = new TodoManager(fileManager, stepLogger);
-  let planContent = "";
-  try {
-    for await (const message of response) {
-      const todoList = await todoManager.checkAndPersistFromMessage(
-        message,
-        task.id
-      );
-      if (todoList) {
-        await sendNotification(POSTHOG_NOTIFICATIONS.ARTIFACT, {
-          sessionId,
-          kind: "todos",
-          content: todoList
-        });
-      }
-      if (message.type === "assistant" && message.message?.content) {
-        for (const block of message.message.content) {
-          if (block.type === "text" && block.text) {
-            planContent += `${block.text}
-`;
-          }
-        }
-      }
-    }
-  } catch (error) {
-    stepLogger.error("Error during plan step query", error);
-    throw error;
-  }
-  if (planContent.trim()) {
-    await fileManager.writePlan(task.id, planContent.trim());
-    stepLogger.info("Plan completed", { taskId: task.id });
-  }
-  await gitManager.addAllPostHogFiles();
-  await finalizeStepGitActions(context, step, {
-    commitMessage: `Planning phase for ${task.title}`
-  });
-  if (!isCloudMode) {
-    await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-      sessionId,
-      phase: "planning"
-    });
-    return { status: "completed", halt: true };
-  }
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-    sessionId,
-    phase: "planning"
-  });
-  return { status: "completed" };
-};
-
-// src/workflow/steps/research.ts
-import { query as query4 } from "@anthropic-ai/claude-agent-sdk";
-
-// src/agents/research.ts
-var RESEARCH_SYSTEM_PROMPT = `<role>
-PostHog AI Research Agent \u2014 analyze codebases to evaluate task actionability and identify missing information.
-</role>
-
-<constraints>
-- Read-only: analyze files, search code, explore structure
-- No modifications or code changes
-- Output structured JSON only
-</constraints>
-
-<objective>
-Your PRIMARY goal is to evaluate whether a task is actionable and assign an actionability score.
-
-Calculate an actionabilityScore (0-1) based on:
-- **Task clarity** (0.4 weight): Is the task description specific and unambiguous?
-- **Codebase context** (0.3 weight): Can you locate the relevant code and patterns?
-- **Architectural decisions** (0.2 weight): Are the implementation approaches clear?
-- **Dependencies** (0.1 weight): Are required dependencies and constraints understood?
-
-If actionabilityScore < 0.7, generate specific clarifying questions to increase confidence.
-
-Questions must present complete implementation choices, NOT request information from the user:
-options: array of strings
-- GOOD: options: ["Use Redux Toolkit (matches pattern in src/store/)", "Zustand (lighter weight)"]
-- BAD:  "Tell me which state management library to use"
-- GOOD: options: ["Place in Button.tsx (existing component)", "create NewButton.tsx (separate concerns)?"]
-- BAD: "Where should I put this code?"
-
-DO NOT ask questions like "how should I fix this" or "tell me the pattern" \u2014 present concrete options that can be directly chosen and acted upon.
-</objective>
-
-<process>
-1. Explore repository structure and identify relevant files/components
-2. Understand existing patterns, conventions, and dependencies
-3. Calculate actionabilityScore based on clarity, context, architecture, and dependencies
-4. Identify key files that will need modification
-5. If score < 0.7: generate 2-4 specific questions to resolve blockers
-6. Output JSON matching ResearchEvaluation schema
-</process>
-
-<output_format>
-Output ONLY valid JSON with no markdown wrappers, no preamble, no explanation:
-
-{
-  "actionabilityScore": 0.85,
-  "context": "Brief 2-3 sentence summary of the task and implementation approach",
-  "keyFiles": ["path/to/file1.ts", "path/to/file2.ts"],
-  "blockers": ["Optional: what's preventing full confidence"],
-  "questions": [
-    {
-      "id": "q1",
-      "question": "Specific architectural decision needed?",
-      "options": [
-        "First approach with concrete details",
-        "Alternative approach with concrete details",
-        "Third option if needed"
-      ]
-    }
-  ]
-}
-
-Rules:
-- actionabilityScore: number between 0 and 1
-- context: concise summary for planning phase
-- keyFiles: array of file paths that need modification
-- blockers: optional array explaining confidence gaps
-- questions: ONLY include if actionabilityScore < 0.7
-- Each question must have 2-3 options (maximum 3)
-- Max 3 questions total
-- Options must be complete, actionable choices that require NO additional user input
-- NEVER use options like "Tell me the pattern", "Show me examples", "Specify the approach"
-- Each option must be a full implementation decision that can be directly acted upon
-</output_format>
-
-<scoring_examples>
-<example score="0.9">
-Task: "Fix typo in login button text"
-Reasoning: Completely clear task, found exact component, no architectural decisions
-</example>
-
-<example score="0.75">
-Task: "Add caching to API endpoints"
-Reasoning: Clear goal, found endpoints, but multiple caching strategies possible
-</example>
-
-<example score="0.55">
-Task: "Improve performance"
-Reasoning: Vague task, unclear scope, needs questions about which areas to optimize
-Questions needed: Which features are slow? What metrics define success?
-</example>
-
-<example score="0.3">
-Task: "Add the new feature"
-Reasoning: Extremely vague, no context, cannot locate relevant code
-Questions needed: What feature? Which product area? What should it do?
-</example>
-</scoring_examples>
-
-<question_examples>
-<good_example>
-{
-  "id": "q1",
-  "question": "Which caching layer should we use for API responses?",
-  "options": [
-    "Redis with 1-hour TTL (existing infrastructure, requires Redis client setup)",
-    "In-memory LRU cache with 100MB limit (simpler, single-server only)",
-    "HTTP Cache-Control headers only (minimal backend changes, relies on browser/CDN)"
-  ]
-}
-Reason: Each option is a complete, actionable decision with concrete details
-</good_example>
-
-<good_example>
-{
-  "id": "q2",
-  "question": "Where should the new analytics tracking code be placed?",
-  "options": [
-    "In the existing UserAnalytics.ts module alongside page view tracking",
-    "Create a new EventTracking.ts module in src/analytics/ for all event tracking",
-    "Add directly to each component that needs tracking (no centralized module)"
-  ]
-}
-Reason: Specific file paths and architectural patterns, no user input needed
-</good_example>
-
-<bad_example>
-{
-  "id": "q1", 
-  "question": "How should I implement this?",
-  "options": ["One way", "Another way"]
-}
-Reason: Too vague, doesn't explain the tradeoffs or provide concrete details
-</bad_example>
-
-<bad_example>
-{
-  "id": "q2",
-  "question": "Which pattern should we follow for state management?",
-  "options": [
-    "Tell me which pattern the codebase currently uses",
-    "Show me examples of state management",
-    "Whatever you think is best"
-  ]
-}
-Reason: Options request user input instead of being actionable choices. Should be concrete patterns like "Zustand stores (matching existing patterns in src/stores/)" or "React Context (simpler, no new dependencies)"
-</bad_example>
-
-<bad_example>
-{
-  "id": "q3",
-  "question": "What color scheme should the button use?",
-  "options": [
-    "Use the existing theme colors",
-    "Let me specify custom colors",
-    "Match the design system"
-  ]
-}
-Reason: "Let me specify" requires user input. Should be "Primary blue (#0066FF, existing theme)" or "Secondary gray (#6B7280, existing theme)"
-</bad_example>
-</question_examples>`;
-
-// src/workflow/steps/research.ts
-var researchStep = async ({ step, context }) => {
-  const {
-    task,
-    cwd,
-    isCloudMode,
-    options,
-    logger: logger2,
-    fileManager,
-    gitManager,
-    promptBuilder,
-    sessionId,
-    mcpServers,
-    sendNotification
-  } = context;
-  const stepLogger = logger2.child("ResearchStep");
-  const existingResearch = await fileManager.readResearch(task.id);
-  if (existingResearch) {
-    stepLogger.info("Research already exists", {
-      taskId: task.id,
-      hasQuestions: !!existingResearch.questions,
-      answered: existingResearch.answered
-    });
-    if (existingResearch.questions && !existingResearch.answered) {
-      stepLogger.info("Re-emitting unanswered research questions", {
-        taskId: task.id,
-        questionCount: existingResearch.questions.length
-      });
-      await sendNotification(POSTHOG_NOTIFICATIONS.ARTIFACT, {
-        sessionId,
-        kind: "research_questions",
-        content: existingResearch.questions
-      });
-      if (!isCloudMode) {
-        await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-          sessionId,
-          phase: "research"
-        });
-        return { status: "skipped", halt: true };
-      }
-    }
-    return { status: "skipped" };
-  }
-  stepLogger.info("Starting research phase", { taskId: task.id });
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_START, {
-    sessionId,
-    phase: "research"
-  });
-  const researchPrompt = await promptBuilder.buildResearchPrompt(task, cwd);
-  const fullPrompt = `${RESEARCH_SYSTEM_PROMPT}
-
-${researchPrompt}`;
-  const baseOptions = {
-    model: step.model,
-    cwd,
-    permissionMode: "plan",
-    settingSources: ["local"],
-    mcpServers,
-    // Allow research tools: read-only operations, web search, and MCP resources
-    allowedTools: [
-      "Read",
-      "Glob",
-      "Grep",
-      "WebFetch",
-      "WebSearch",
-      "ListMcpResources",
-      "ReadMcpResource",
-      "TodoWrite",
-      "BashOutput"
-    ]
-  };
-  const response = query4({
-    prompt: fullPrompt,
-    options: { ...baseOptions, ...options.queryOverrides || {} }
-  });
-  let jsonContent = "";
-  try {
-    for await (const message of response) {
-      if (message.type === "assistant" && message.message?.content) {
-        for (const c of message.message.content) {
-          if (c.type === "text" && c.text) {
-            jsonContent += c.text;
-          }
-        }
-      }
-    }
-  } catch (error) {
-    stepLogger.error("Error during research step query", error);
-    throw error;
-  }
-  if (!jsonContent.trim()) {
-    stepLogger.error("No JSON output from research agent", { taskId: task.id });
-    await sendNotification(POSTHOG_NOTIFICATIONS.ERROR, {
-      sessionId,
-      message: "Research agent returned no output"
-    });
-    return { status: "completed", halt: true };
-  }
-  let evaluation;
-  try {
-    const jsonMatch = jsonContent.match(/\{[\s\S]*\}/);
-    if (!jsonMatch) {
-      throw new Error("No JSON object found in response");
-    }
-    evaluation = JSON.parse(jsonMatch[0]);
-    stepLogger.info("Parsed research evaluation", {
-      taskId: task.id,
-      score: evaluation.actionabilityScore,
-      hasQuestions: !!evaluation.questions
-    });
-  } catch (error) {
-    stepLogger.error("Failed to parse research JSON", {
-      taskId: task.id,
-      error: error instanceof Error ? error.message : String(error),
-      content: jsonContent.substring(0, 500)
-    });
-    await sendNotification(POSTHOG_NOTIFICATIONS.ERROR, {
-      sessionId,
-      message: `Failed to parse research JSON: ${error instanceof Error ? error.message : String(error)}`
-    });
-    return { status: "completed", halt: true };
-  }
-  if (evaluation.questions && evaluation.questions.length > 0) {
-    evaluation.answered = false;
-    evaluation.answers = void 0;
-  }
-  await fileManager.writeResearch(task.id, evaluation);
-  stepLogger.info("Research evaluation written", {
-    taskId: task.id,
-    score: evaluation.actionabilityScore,
-    hasQuestions: !!evaluation.questions
-  });
-  await sendNotification(POSTHOG_NOTIFICATIONS.ARTIFACT, {
-    sessionId,
-    kind: "research_evaluation",
-    content: evaluation
-  });
-  await gitManager.addAllPostHogFiles();
-  await finalizeStepGitActions(context, step, {
-    commitMessage: `Research phase for ${task.title}`
-  });
-  if (evaluation.actionabilityScore < 0.7 && evaluation.questions && evaluation.questions.length > 0) {
-    stepLogger.info("Actionability score below threshold, questions needed", {
-      taskId: task.id,
-      score: evaluation.actionabilityScore,
-      questionCount: evaluation.questions.length
-    });
-    await sendNotification(POSTHOG_NOTIFICATIONS.ARTIFACT, {
-      sessionId,
-      kind: "research_questions",
-      content: evaluation.questions
-    });
-  } else {
-    stepLogger.info("Actionability score acceptable, proceeding to planning", {
-      taskId: task.id,
-      score: evaluation.actionabilityScore
-    });
-  }
-  if (!isCloudMode) {
-    await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-      sessionId,
-      phase: "research"
-    });
-    return { status: "completed", halt: true };
+      const execution = this.executionStates.get(executionId);
+      if (execution && execution.status === "running") {
+        execution.status = "timeout";
+        execution.completedAt = Date.now();
+        execution.abortController?.abort();
+        if (!execution.result) {
+          execution.result = {
+            status: "timeout",
+            message: "Execution timed out"
+          };
+        }
+      }
+    }, timeout);
   }
-  const researchData = await fileManager.readResearch(task.id);
-  if (researchData?.questions && !researchData.answered) {
-    await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-      sessionId,
-      phase: "research"
-    });
-    return { status: "completed", halt: true };
+  cleanup(olderThan = 60 * 60 * 1e3) {
+    const cutoff = Date.now() - olderThan;
+    for (const [executionId, execution] of this.executionStates) {
+      if (execution.completedAt && execution.completedAt < cutoff) {
+        this.executionStates.delete(executionId);
+      }
+    }
   }
-  await sendNotification(POSTHOG_NOTIFICATIONS.PHASE_COMPLETE, {
-    sessionId,
-    phase: "research"
-  });
-  return { status: "completed" };
 };
 
-// src/workflow/config.ts
-var MODELS = {
-  SONNET: "claude-sonnet-4-5",
-  HAIKU: "claude-haiku-4-5"
-};
-var TASK_WORKFLOW = [
-  {
-    id: "research",
-    name: "Research",
-    agent: "research",
-    model: MODELS.HAIKU,
-    permissionMode: "plan",
-    commit: true,
-    push: true,
-    run: researchStep
-  },
-  {
-    id: "plan",
-    name: "Plan",
-    agent: "planning",
-    model: MODELS.SONNET,
-    permissionMode: "plan",
-    commit: true,
-    push: true,
-    run: planStep
-  },
-  {
-    id: "build",
-    name: "Build",
-    agent: "execution",
-    model: MODELS.SONNET,
-    permissionMode: "acceptEdits",
-    commit: true,
-    push: true,
-    run: buildStep
-  },
-  {
-    id: "finalize",
-    name: "Finalize",
-    agent: "system",
-    // not used
-    model: MODELS.HAIKU,
-    // not used
-    permissionMode: "plan",
-    // not used
-    commit: true,
-    push: true,
-    run: finalizeStep
-  }
-];
+// src/types.ts
+var PermissionMode = /* @__PURE__ */ ((PermissionMode2) => {
+  PermissionMode2["PLAN"] = "plan";
+  PermissionMode2["DEFAULT"] = "default";
+  PermissionMode2["ACCEPT_EDITS"] = "acceptEdits";
+  PermissionMode2["BYPASS"] = "bypassPermissions";
+  return PermissionMode2;
+})(PermissionMode || {});
 
 // src/agent.ts
 var Agent = class {
@@ -5638,10 +4299,8 @@ var Agent = class {
   posthogAPI;
   fileManager;
   gitManager;
-  templateManager;
   logger;
   acpConnection;
-  promptBuilder;
   mcpServers;
   canUseTool;
   currentRunId;
@@ -5681,7 +4340,6 @@ var Agent = class {
       repositoryPath: this.workingDirectory,
       logger: this.logger.child("GitManager")
     });
-    this.templateManager = new TemplateManager();
     if (config.posthogApiUrl && config.getPosthogApiKey && config.posthogProjectId) {
       this.posthogAPI = new PostHogAPIClient({
         apiUrl: config.posthogApiUrl,
@@ -5693,12 +4351,6 @@ var Agent = class {
         this.logger.child("SessionStore")
       );
     }
-    this.promptBuilder = new PromptBuilder({
-      getTaskFiles: (taskId) => this.getTaskFiles(taskId),
-      generatePlanTemplate: (vars) => this.templateManager.generatePlan(vars),
-      posthogClient: this.posthogAPI,
-      logger: this.logger.child("PromptBuilder")
-    });
   }
   /**
    * Enable or disable debug logging
@@ -5726,88 +4378,14 @@ var Agent = class {
       throw error;
     }
   }
-  getOrCreateConnection() {
-    if (!this.acpConnection) {
-      this.acpConnection = createAcpConnection({
-        sessionStore: this.sessionStore
-      });
-    }
-    return this.acpConnection;
-  }
-  // Adaptive task execution orchestrated via workflow steps
-  async runTask(taskId, taskRunId, options = {}) {
-    const task = await this.fetchTask(taskId);
-    const cwd = options.repositoryPath || this.workingDirectory;
-    const isCloudMode = options.isCloudMode ?? false;
-    const taskSlug = task.slug || task.id;
-    this.currentRunId = taskRunId;
-    this.logger.info("Starting adaptive task execution", {
-      taskId: task.id,
-      taskSlug,
-      taskRunId,
-      isCloudMode
-    });
-    const connection = this.getOrCreateConnection();
-    const sendNotification = async (method, params) => {
-      this.logger.debug(`Notification: ${method}`, params);
-      await connection.agentConnection.extNotification?.(method, params);
-    };
-    await sendNotification(POSTHOG_NOTIFICATIONS.RUN_STARTED, {
-      sessionId: taskRunId,
-      runId: taskRunId
-    });
-    await this.prepareTaskBranch(taskSlug, isCloudMode, sendNotification);
-    let taskError;
-    try {
-      const workflowContext = {
-        task,
-        taskSlug,
-        runId: taskRunId,
-        cwd,
-        isCloudMode,
-        options,
-        logger: this.logger,
-        fileManager: this.fileManager,
-        gitManager: this.gitManager,
-        promptBuilder: this.promptBuilder,
-        connection: connection.agentConnection,
-        sessionId: taskRunId,
-        sendNotification,
-        mcpServers: this.mcpServers,
-        posthogAPI: this.posthogAPI,
-        stepResults: {}
-      };
-      for (const step of TASK_WORKFLOW) {
-        const result = await step.run({ step, context: workflowContext });
-        if (result.halt) {
-          return;
-        }
-      }
-      const shouldCreatePR = options.createPR ?? isCloudMode;
-      if (shouldCreatePR) {
-        await this.ensurePullRequest(
-          task,
-          workflowContext.stepResults,
-          sendNotification
-        );
-      }
-      this.logger.info("Task execution complete", { taskId: task.id });
-      await sendNotification(POSTHOG_NOTIFICATIONS.TASK_COMPLETE, {
-        sessionId: taskRunId,
-        taskId: task.id
-      });
-    } catch (error) {
-      taskError = error instanceof Error ? error : new Error(String(error));
-      this.logger.error("Task execution failed", {
-        taskId: task.id,
-        error: taskError.message
-      });
-      await sendNotification(POSTHOG_NOTIFICATIONS.ERROR, {
-        sessionId: taskRunId,
-        message: taskError.message
-      });
-      throw taskError;
-    }
+  /**
+   * @deprecated Use runTaskV2() for local execution or runTaskCloud() for cloud execution.
+   * This method used the old workflow system which has been removed.
+   */
+  async runTask(_taskId, _taskRunId, _options = {}) {
+    throw new Error(
+      "runTask() is deprecated. Use runTaskV2() for local execution or runTaskCloud() for cloud execution."
+    );
   }
   /**
    * Creates an in-process ACP connection for client communication.
@@ -5818,15 +4396,14 @@ var Agent = class {
    */
   async runTaskV2(taskId, taskRunId, options = {}) {
     await this._configureLlmGateway();
-    const task = await this.fetchTask(taskId);
-    const taskSlug = task.slug || task.id;
     const isCloudMode = options.isCloudMode ?? false;
     const _cwd = options.repositoryPath || this.workingDirectory;
     this.currentRunId = taskRunId;
     this.acpConnection = createAcpConnection({
+      framework: options.framework,
       sessionStore: this.sessionStore,
       sessionId: taskRunId,
-      taskId: task.id
+      taskId
     });
     const sendNotification = async (method, params) => {
       this.logger.debug(`Notification: ${method}`, params);
@@ -5835,11 +4412,15 @@ var Agent = class {
         params
       );
     };
-    await sendNotification(POSTHOG_NOTIFICATIONS.RUN_STARTED, {
-      sessionId: taskRunId,
-      runId: taskRunId
-    });
+    if (!options.isReconnect) {
+      await sendNotification(POSTHOG_NOTIFICATIONS.RUN_STARTED, {
+        sessionId: taskRunId,
+        runId: taskRunId
+      });
+    }
     if (!options.skipGitBranch) {
+      const task = options.task ?? await this.fetchTask(taskId);
+      const taskSlug = task.slug || task.id;
       try {
         await this.prepareTaskBranch(taskSlug, isCloudMode, sendNotification);
       } catch (error) {
@@ -6193,47 +4774,6 @@ ${task.description}`
       throw error;
     }
   }
-  async ensurePullRequest(task, stepResults, sendNotification) {
-    const latestRun = task.latest_run;
-    const existingPr = latestRun?.output && typeof latestRun.output === "object" ? latestRun.output.pr_url : null;
-    if (existingPr) {
-      this.logger.info("PR already exists, skipping creation", {
-        taskId: task.id,
-        prUrl: existingPr
-      });
-      return;
-    }
-    const buildResult = stepResults.build;
-    if (!buildResult?.commitCreated) {
-      this.logger.warn(
-        "Build step did not produce a commit; skipping PR creation",
-        { taskId: task.id }
-      );
-      return;
-    }
-    const branchName = await this.gitManager.getCurrentBranch();
-    const finalizeResult = stepResults.finalize;
-    const prBody = finalizeResult?.prBody;
-    const prUrl = await this.createPullRequest(
-      task.id,
-      branchName,
-      task.title,
-      task.description ?? "",
-      prBody
-    );
-    await sendNotification(POSTHOG_NOTIFICATIONS.PR_CREATED, { prUrl });
-    try {
-      await this.attachPullRequestToTask(task.id, prUrl, branchName);
-      this.logger.info("PR attached to task successfully", {
-        taskId: task.id,
-        prUrl
-      });
-    } catch (error) {
-      this.logger.warn("Could not attach PR to task", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
 };
 
 // src/schemas.ts
@@ -6408,6 +4948,131 @@ function parseAgentEvents(inputs) {
   return inputs.map((input) => parseAgentEvent(input)).filter((event) => event !== null);
 }
 
+// src/todo-manager.ts
+var TodoManager = class {
+  fileManager;
+  logger;
+  constructor(fileManager, logger) {
+    this.fileManager = fileManager;
+    this.logger = logger || new Logger({ debug: false, prefix: "[TodoManager]" });
+  }
+  async readTodos(taskId) {
+    try {
+      const content = await this.fileManager.readTaskFile(taskId, "todos.json");
+      if (!content) {
+        return null;
+      }
+      const parsed = JSON.parse(content);
+      this.logger.debug("Loaded todos", {
+        taskId,
+        total: parsed.metadata.total,
+        pending: parsed.metadata.pending,
+        in_progress: parsed.metadata.in_progress,
+        completed: parsed.metadata.completed
+      });
+      return parsed;
+    } catch (error) {
+      this.logger.debug("Failed to read todos.json", {
+        taskId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  async writeTodos(taskId, todos) {
+    this.logger.debug("Writing todos", {
+      taskId,
+      total: todos.metadata.total,
+      pending: todos.metadata.pending,
+      in_progress: todos.metadata.in_progress,
+      completed: todos.metadata.completed
+    });
+    await this.fileManager.writeTaskFile(taskId, {
+      name: "todos.json",
+      content: JSON.stringify(todos, null, 2),
+      type: "artifact"
+    });
+    this.logger.info("Todos saved", {
+      taskId,
+      total: todos.metadata.total,
+      completed: todos.metadata.completed
+    });
+  }
+  parseTodoWriteInput(toolInput) {
+    const items = [];
+    if (toolInput.todos && Array.isArray(toolInput.todos)) {
+      for (const todo of toolInput.todos) {
+        items.push({
+          content: todo.content || "",
+          status: todo.status || "pending",
+          activeForm: todo.activeForm || todo.content || ""
+        });
+      }
+    }
+    const metadata = this.calculateMetadata(items);
+    return { items, metadata };
+  }
+  calculateMetadata(items) {
+    const total = items.length;
+    const pending = items.filter((t) => t.status === "pending").length;
+    const in_progress = items.filter((t) => t.status === "in_progress").length;
+    const completed = items.filter((t) => t.status === "completed").length;
+    return {
+      total,
+      pending,
+      in_progress,
+      completed,
+      last_updated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async getTodoContext(taskId) {
+    const todos = await this.readTodos(taskId);
+    if (!todos || todos.items.length === 0) {
+      return "";
+    }
+    const lines = ["## Previous Todo List\n"];
+    lines.push("You previously created the following todo list:\n");
+    for (const item of todos.items) {
+      const statusIcon = item.status === "completed" ? "\u2713" : item.status === "in_progress" ? "\u25B6" : "\u25CB";
+      lines.push(`${statusIcon} [${item.status}] ${item.content}`);
+    }
+    lines.push(
+      `
+Progress: ${todos.metadata.completed}/${todos.metadata.total} completed
+`
+    );
+    return lines.join("\n");
+  }
+  // check for TodoWrite tool call and persist if found
+  async checkAndPersistFromMessage(message, taskId) {
+    if (message.type !== "assistant" || typeof message.message !== "object" || !message.message || !("content" in message.message) || !Array.isArray(message.message.content)) {
+      return null;
+    }
+    for (const block of message.message.content) {
+      if (block.type === "tool_use" && block.name === "TodoWrite") {
+        try {
+          this.logger.info("TodoWrite detected, persisting todos", { taskId });
+          const todoList = this.parseTodoWriteInput(block.input);
+          await this.writeTodos(taskId, todoList);
+          this.logger.info("Persisted todos successfully", {
+            taskId,
+            total: todoList.metadata.total,
+            completed: todoList.metadata.completed
+          });
+          return todoList;
+        } catch (error) {
+          this.logger.error("Failed to persist todos", {
+            taskId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+};
+
 // src/tools/registry.ts
 var TOOL_DEFINITIONS = {
   // Filesystem tools
@@ -6485,6 +5150,11 @@ var TOOL_DEFINITIONS = {
     category: "assistant",
     description: "Exit plan mode and present plan to user"
   },
+  AskUserQuestion: {
+    name: "AskUserQuestion",
+    category: "assistant",
+    description: "Ask the user a clarifying question with options"
+  },
   SlashCommand: {
     name: "SlashCommand",
     category: "assistant",
@@ -6522,12 +5192,11 @@ var ToolRegistry = class {
 };
 
 // src/worktree-manager.ts
-import { exec as exec2, execFile } from "child_process";
+import { execFile } from "child_process";
 import * as crypto from "crypto";
-import * as fs5 from "fs/promises";
+import * as fs3 from "fs/promises";
 import * as path2 from "path";
 import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(exec2);
 var execFileAsync = promisify2(execFile);
 var ADJECTIVES = [
   "swift",
@@ -7017,14 +5686,14 @@ var WorktreeManager = class {
   usesExternalPath() {
     return this.worktreeBasePath !== null;
   }
-  async runGitCommand(command) {
+  async runGitCommand(args) {
     try {
-      const { stdout } = await execAsync2(`git ${command}`, {
+      const { stdout } = await execFileAsync("git", args, {
         cwd: this.mainRepoPath
       });
       return stdout.trim();
     } catch (error) {
-      throw new Error(`Git command failed: ${command}
+      throw new Error(`Git command failed: git ${args.join(" ")}
 ${error}`);
     }
   }
@@ -7049,7 +5718,7 @@ ${error}`);
   async worktreeExists(name) {
     const worktreePath = this.getWorktreePath(name);
     try {
-      await fs5.access(worktreePath);
+      await fs3.access(worktreePath);
       return true;
     } catch {
       return false;
@@ -7060,7 +5729,7 @@ ${error}`);
     const ignorePattern = `/${WORKTREE_FOLDER_NAME}/`;
     let content = "";
     try {
-      content = await fs5.readFile(excludePath, "utf-8");
+      content = await fs3.readFile(excludePath, "utf-8");
     } catch {
     }
     if (content.includes(`/${WORKTREE_FOLDER_NAME}/`) || content.includes(`/${WORKTREE_FOLDER_NAME}`)) {
@@ -7068,13 +5737,13 @@ ${error}`);
       return;
     }
     const infoDir = path2.join(this.mainRepoPath, ".git", "info");
-    await fs5.mkdir(infoDir, { recursive: true });
+    await fs3.mkdir(infoDir, { recursive: true });
     const newContent = `${content.trimEnd()}
 
 # Array worktrees
 ${ignorePattern}
 `;
-    await fs5.writeFile(excludePath, newContent);
+    await fs3.writeFile(excludePath, newContent);
     this.logger.info("Added .array folder to .git/info/exclude");
   }
   async generateUniqueWorktreeName() {
@@ -7091,61 +5760,83 @@ ${ignorePattern}
     return name;
   }
   async getDefaultBranch() {
-    try {
-      const remoteBranch = await this.runGitCommand(
-        "symbolic-ref refs/remotes/origin/HEAD"
-      );
-      return remoteBranch.replace("refs/remotes/origin/", "");
-    } catch {
-      try {
-        await this.runGitCommand("rev-parse --verify main");
-        return "main";
-      } catch {
-        try {
-          await this.runGitCommand("rev-parse --verify master");
-          return "master";
-        } catch {
-          throw new Error(
-            "Cannot determine default branch. No main or master branch found."
-          );
-        }
-      }
-    }
+    const [symbolicRef, mainExists, masterExists] = await Promise.allSettled([
+      this.runGitCommand(["symbolic-ref", "refs/remotes/origin/HEAD"]),
+      this.runGitCommand(["rev-parse", "--verify", "main"]),
+      this.runGitCommand(["rev-parse", "--verify", "master"])
+    ]);
+    if (symbolicRef.status === "fulfilled") {
+      return symbolicRef.value.replace("refs/remotes/origin/", "");
+    }
+    if (mainExists.status === "fulfilled") {
+      return "main";
+    }
+    if (masterExists.status === "fulfilled") {
+      return "master";
+    }
+    throw new Error(
+      "Cannot determine default branch. No main or master branch found."
+    );
   }
   async createWorktree(options) {
+    const totalStart = Date.now();
+    const setupPromises = [];
     if (!this.usesExternalPath()) {
-      await this.ensureArrayDirIgnored();
-    }
-    if (this.usesExternalPath()) {
+      setupPromises.push(this.ensureArrayDirIgnored());
+    } else {
       const folderPath = this.getWorktreeFolderPath();
-      await fs5.mkdir(folderPath, { recursive: true });
-    }
-    const worktreeName = await this.generateUniqueWorktreeName();
+      setupPromises.push(fs3.mkdir(folderPath, { recursive: true }));
+    }
+    const worktreeNamePromise = this.generateUniqueWorktreeName();
+    setupPromises.push(worktreeNamePromise);
+    const baseBranchPromise = options?.baseBranch ? Promise.resolve(options.baseBranch) : this.getDefaultBranch();
+    setupPromises.push(baseBranchPromise);
+    await Promise.all(setupPromises);
+    const setupTime = Date.now() - totalStart;
+    const worktreeName = await worktreeNamePromise;
+    const baseBranch = await baseBranchPromise;
     const worktreePath = this.getWorktreePath(worktreeName);
     const branchName = `array/${worktreeName}`;
-    const baseBranch = options?.baseBranch ?? await this.getDefaultBranch();
     this.logger.info("Creating worktree", {
       worktreeName,
       worktreePath,
       branchName,
       baseBranch,
-      external: this.usesExternalPath()
+      external: this.usesExternalPath(),
+      setupTimeMs: setupTime
     });
+    const gitStart = Date.now();
     if (this.usesExternalPath()) {
-      await this.runGitCommand(
-        `worktree add -b "${branchName}" "${worktreePath}" "${baseBranch}"`
-      );
+      await this.runGitCommand([
+        "worktree",
+        "add",
+        "--quiet",
+        "-b",
+        branchName,
+        worktreePath,
+        baseBranch
+      ]);
     } else {
-      const relativePath = `${WORKTREE_FOLDER_NAME}/${worktreeName}`;
-      await this.runGitCommand(
-        `worktree add -b "${branchName}" "./${relativePath}" "${baseBranch}"`
-      );
-    }
+      const relativePath = `./${WORKTREE_FOLDER_NAME}/${worktreeName}`;
+      await this.runGitCommand([
+        "worktree",
+        "add",
+        "--quiet",
+        "-b",
+        branchName,
+        relativePath,
+        baseBranch
+      ]);
+    }
+    const gitTime = Date.now() - gitStart;
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
     this.logger.info("Worktree created successfully", {
       worktreeName,
       worktreePath,
-      branchName
+      branchName,
+      setupTimeMs: setupTime,
+      gitWorktreeAddMs: gitTime,
+      totalMs: Date.now() - totalStart
     });
     return {
       worktreePath,
@@ -7174,7 +5865,7 @@ ${ignorePattern}
     }
     try {
       const gitPath = path2.join(resolvedWorktreePath, ".git");
-      const stat2 = await fs5.stat(gitPath);
+      const stat2 = await fs3.stat(gitPath);
       if (stat2.isDirectory()) {
         const error = new Error(
           "Cannot delete worktree: path appears to be a main repository (contains .git directory)"
@@ -7206,8 +5897,8 @@ ${ignorePattern}
         }
       );
       try {
-        await fs5.rm(worktreePath, { recursive: true, force: true });
-        await this.runGitCommand("worktree prune");
+        await fs3.rm(worktreePath, { recursive: true, force: true });
+        await this.runGitCommand(["worktree", "prune"]);
         this.logger.info("Worktree cleaned up manually", { worktreePath });
       } catch (cleanupError) {
         this.logger.error("Failed to cleanup worktree", {
@@ -7220,7 +5911,11 @@ ${ignorePattern}
   }
   async getWorktreeInfo(worktreePath) {
     try {
-      const output = await this.runGitCommand("worktree list --porcelain");
+      const output = await this.runGitCommand([
+        "worktree",
+        "list",
+        "--porcelain"
+      ]);
       const worktrees = this.parseWorktreeList(output);
       const worktree = worktrees.find((w) => w.worktreePath === worktreePath);
       return worktree || null;
@@ -7231,7 +5926,11 @@ ${ignorePattern}
   }
   async listWorktrees() {
     try {
-      const output = await this.runGitCommand("worktree list --porcelain");
+      const output = await this.runGitCommand([
+        "worktree",
+        "list",
+        "--porcelain"
+      ]);
       return this.parseWorktreeList(output);
     } catch (error) {
       this.logger.debug("Failed to list worktrees", { error });
@@ -7270,15 +5969,16 @@ ${ignorePattern}
   }
   async isWorktree(repoPath) {
     try {
-      const { stdout } = await execAsync2(
-        "git rev-parse --is-inside-work-tree",
+      const { stdout } = await execFileAsync(
+        "git",
+        ["rev-parse", "--is-inside-work-tree"],
         { cwd: repoPath }
       );
       if (stdout.trim() !== "true") {
         return false;
       }
       const gitPath = path2.join(repoPath, ".git");
-      const stat2 = await fs5.stat(gitPath);
+      const stat2 = await fs3.stat(gitPath);
       return stat2.isFile();
     } catch {
       return false;
@@ -7287,7 +5987,7 @@ ${ignorePattern}
   async getMainRepoPathFromWorktree(worktreePath) {
     try {
       const gitFilePath = path2.join(worktreePath, ".git");
-      const content = await fs5.readFile(gitFilePath, "utf-8");
+      const content = await fs3.readFile(gitFilePath, "utf-8");
       const match = content.match(/gitdir:\s*(.+)/);
       if (match) {
         const gitDir = match[1].trim();