@rallycry/conveyor-agent 2.7.0 → 2.9.0

package/dist/chunk-42BYQ6YY.js

@@ -0,0 +1,1415 @@
+// src/connection.ts
+import { io } from "socket.io-client";
+var ConveyorConnection = class _ConveyorConnection {
+  socket = null;
+  config;
+  eventBuffer = [];
+  flushTimer = null;
+  static EVENT_BATCH_MS = 500;
+  earlyMessages = [];
+  earlyStop = false;
+  chatMessageCallback = null;
+  stopCallback = null;
+  pendingQuestionResolvers = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let attempts = 0;
+      const maxInitialAttempts = 30;
+      this.socket = io(this.config.conveyorApiUrl, {
+        auth: { taskToken: this.config.taskToken, runnerMode: this.config.mode ?? "task" },
+        transports: ["websocket"],
+        reconnection: true,
+        reconnectionAttempts: Infinity,
+        reconnectionDelay: 2e3,
+        reconnectionDelayMax: 3e4,
+        randomizationFactor: 0.3,
+        extraHeaders: {
+          "ngrok-skip-browser-warning": "true"
+        }
+      });
+      this.socket.on("agentRunner:incomingMessage", (msg) => {
+        if (this.chatMessageCallback) {
+          this.chatMessageCallback(msg);
+        } else {
+          this.earlyMessages.push(msg);
+        }
+      });
+      this.socket.on("agentRunner:stop", () => {
+        if (this.stopCallback) {
+          this.stopCallback();
+        } else {
+          this.earlyStop = true;
+        }
+      });
+      this.socket.on(
+        "agentRunner:questionAnswer",
+        (data) => {
+          const resolver = this.pendingQuestionResolvers.get(data.requestId);
+          if (resolver) {
+            this.pendingQuestionResolvers.delete(data.requestId);
+            resolver(data.answers);
+          }
+        }
+      );
+      this.socket.on("connect", () => {
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      });
+      this.socket.io.on("reconnect_attempt", () => {
+        attempts++;
+        if (!settled && attempts >= maxInitialAttempts) {
+          settled = true;
+          reject(new Error(`Failed to connect after ${maxInitialAttempts} attempts`));
+        }
+      });
+    });
+  }
+  fetchChatMessages(limit) {
+    const socket = this.socket;
+    if (!socket) throw new Error("Not connected");
+    return new Promise((resolve, reject) => {
+      socket.emit(
+        "agentRunner:getChatMessages",
+        { taskId: this.config.taskId, limit },
+        (response) => {
+          if (response.success && response.data) {
+            resolve(response.data);
+          } else {
+            reject(new Error(response.error ?? "Failed to fetch chat messages"));
+          }
+        }
+      );
+    });
+  }
+  fetchTaskContext() {
+    const socket = this.socket;
+    if (!socket) throw new Error("Not connected");
+    return new Promise((resolve, reject) => {
+      socket.emit(
+        "agentRunner:getTaskContext",
+        { taskId: this.config.taskId },
+        (response) => {
+          if (response.success && response.data) {
+            resolve(response.data);
+          } else {
+            reject(new Error(response.error ?? "Failed to fetch task context"));
+          }
+        }
+      );
+    });
+  }
+  sendEvent(event) {
+    if (!this.socket) throw new Error("Not connected");
+    this.eventBuffer.push({ taskId: this.config.taskId, event });
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => this.flushEvents(), _ConveyorConnection.EVENT_BATCH_MS);
+    }
+  }
+  flushEvents() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (!this.socket || this.eventBuffer.length === 0) return;
+    for (const entry of this.eventBuffer) {
+      this.socket.emit("agentRunner:event", entry);
+    }
+    this.eventBuffer = [];
+  }
+  updateStatus(status) {
+    if (!this.socket) throw new Error("Not connected");
+    this.socket.emit("agentRunner:statusUpdate", {
+      taskId: this.config.taskId,
+      status
+    });
+  }
+  postChatMessage(content) {
+    if (!this.socket) throw new Error("Not connected");
+    this.socket.emit("agentRunner:chatMessage", {
+      taskId: this.config.taskId,
+      content
+    });
+  }
+  createPR(params) {
+    const socket = this.socket;
+    if (!socket) throw new Error("Not connected");
+    return new Promise((resolve, reject) => {
+      socket.emit(
+        "agentRunner:createPR",
+        { taskId: this.config.taskId, ...params },
+        (response) => {
+          if (response.success && response.data) {
+            resolve(response.data);
+          } else {
+            reject(new Error(response.error ?? "Failed to create pull request"));
+          }
+        }
+      );
+    });
+  }
+  askUserQuestion(requestId, questions) {
+    if (!this.socket) throw new Error("Not connected");
+    this.socket.emit("agentRunner:askUserQuestion", {
+      taskId: this.config.taskId,
+      requestId,
+      questions
+    });
+    return new Promise((resolve) => {
+      this.pendingQuestionResolvers.set(requestId, resolve);
+    });
+  }
+  cancelPendingQuestions() {
+    this.pendingQuestionResolvers.clear();
+  }
+  storeSessionId(sessionId) {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:storeSessionId", {
+      taskId: this.config.taskId,
+      sessionId
+    });
+  }
+  updateTaskFields(fields) {
+    if (!this.socket) throw new Error("Not connected");
+    this.socket.emit("agentRunner:updateTaskFields", {
+      taskId: this.config.taskId,
+      fields
+    });
+  }
+  onChatMessage(callback) {
+    this.chatMessageCallback = callback;
+    for (const msg of this.earlyMessages) {
+      callback(msg);
+    }
+    this.earlyMessages = [];
+  }
+  onStopRequested(callback) {
+    this.stopCallback = callback;
+    if (this.earlyStop) {
+      callback();
+      this.earlyStop = false;
+    }
+  }
+  trackSpending(params) {
+    if (!this.socket) throw new Error("Not connected");
+    this.socket.emit("agentRunner:trackSpending", {
+      taskId: this.config.taskId,
+      ...params
+    });
+  }
+  emitStatus(status) {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:statusUpdate", {
+      taskId: this.config.taskId,
+      status
+    });
+  }
+  sendHeartbeat() {
+    if (!this.socket) return;
+    this.socket.emit("agentRunner:heartbeat", {
+      taskId: this.config.taskId
+    });
+  }
+  sendTypingStart() {
+    this.sendEvent({ type: "agent_typing_start" });
+  }
+  sendTypingStop() {
+    this.sendEvent({ type: "agent_typing_stop" });
+  }
+  disconnect() {
+    this.flushEvents();
+    this.socket?.disconnect();
+    this.socket = null;
+  }
+};
+
+// src/setup.ts
+import { execSync } from "child_process";
+import { spawn } from "child_process";
+import { readFile } from "fs/promises";
+import { join } from "path";
+var CONVEYOR_CONFIG_PATH = ".conveyor/config.json";
+var DEVCONTAINER_PATH = ".devcontainer/conveyor/devcontainer.json";
+async function loadForwardPorts(workspaceDir) {
+  try {
+    const raw = await readFile(join(workspaceDir, DEVCONTAINER_PATH), "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed.forwardPorts ?? [];
+  } catch {
+    return [];
+  }
+}
+async function loadConveyorConfig(workspaceDir) {
+  try {
+    const raw = await readFile(join(workspaceDir, CONVEYOR_CONFIG_PATH), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.setupCommand || parsed.startCommand) return parsed;
+  } catch {
+  }
+  try {
+    const raw = await readFile(join(workspaceDir, DEVCONTAINER_PATH), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.conveyor && (parsed.conveyor.startCommand || parsed.conveyor.setupCommand)) {
+      return parsed.conveyor;
+    }
+  } catch {
+  }
+  return null;
+}
+function runSetupCommand(cmd, cwd, onOutput) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("sh", ["-c", cmd], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    child.stdout.on("data", (chunk) => {
+      onOutput("stdout", chunk.toString());
+    });
+    child.stderr.on("data", (chunk) => {
+      onOutput("stderr", chunk.toString());
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Setup command exited with code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+function runStartCommand(cmd, cwd, onOutput) {
+  const child = spawn("sh", ["-c", cmd], {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    env: { ...process.env }
+  });
+  child.stdout.on("data", (chunk) => {
+    onOutput("stdout", chunk.toString());
+  });
+  child.stderr.on("data", (chunk) => {
+    onOutput("stderr", chunk.toString());
+  });
+  child.unref();
+  return child;
+}
+function cleanDevcontainerFromGit(workspaceDir, taskBranch, baseBranch) {
+  const git = (cmd) => execSync(cmd, { cwd: workspaceDir, encoding: "utf-8", timeout: 3e4 }).trim();
+  try {
+    git(`git fetch origin ${baseBranch}`);
+  } catch {
+    return { cleaned: false, message: `Failed to fetch origin/${baseBranch}` };
+  }
+  try {
+    git(`git diff --quiet origin/${baseBranch} -- ${DEVCONTAINER_PATH}`);
+    return { cleaned: false, message: "devcontainer.json already matches base" };
+  } catch {
+  }
+  try {
+    const ahead = parseInt(git(`git rev-list --count origin/${baseBranch}..HEAD`), 10);
+    if (ahead <= 1) {
+      git(`git reset --hard origin/${baseBranch}`);
+    } else {
+      git(`git checkout origin/${baseBranch} -- ${DEVCONTAINER_PATH}`);
+      git(`git add ${DEVCONTAINER_PATH}`);
+      try {
+        git(`git diff --cached --quiet -- ${DEVCONTAINER_PATH}`);
+        return { cleaned: false, message: "devcontainer.json already clean in working tree" };
+      } catch {
+        git(`git commit -m "chore: reset devcontainer config"`);
+      }
+    }
+    git(`git push --force-with-lease origin ${taskBranch}`);
+    return { cleaned: true, message: "devcontainer.json cleaned from git history" };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    return { cleaned: false, message: `Git cleanup failed: ${msg}` };
+  }
+}
+
+// src/worktree.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+var WORKTREE_DIR = ".worktrees";
+function ensureWorktree(projectDir, taskId, branch) {
+  const worktreePath = join2(projectDir, WORKTREE_DIR, taskId);
+  if (existsSync(worktreePath)) {
+    if (branch) {
+      try {
+        execSync2(`git checkout ${branch}`, { cwd: worktreePath, stdio: "ignore" });
+      } catch {
+      }
+    }
+    return worktreePath;
+  }
+  const target = branch ?? "HEAD";
+  execSync2(`git worktree add "${worktreePath}" ${target}`, {
+    cwd: projectDir,
+    stdio: "ignore"
+  });
+  return worktreePath;
+}
+function removeWorktree(projectDir, taskId) {
+  const worktreePath = join2(projectDir, WORKTREE_DIR, taskId);
+  if (!existsSync(worktreePath)) return;
+  try {
+    execSync2(`git worktree remove "${worktreePath}" --force`, {
+      cwd: projectDir,
+      stdio: "ignore"
+    });
+  } catch {
+  }
+}
+
+// src/runner.ts
+import { execSync as execSync3 } from "child_process";
+import { readdirSync, statSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join as join3 } from "path";
+
+// src/query-executor.ts
+import { randomUUID } from "crypto";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// src/prompt-builder.ts
+function findLastAgentMessageIndex(history) {
+  for (let i = history.length - 1; i >= 0; i--) {
+    if (history[i].role === "assistant") return i;
+  }
+  return -1;
+}
+function detectRelaunchScenario(context) {
+  const lastAgentIdx = findLastAgentMessageIndex(context.chatHistory);
+  if (lastAgentIdx === -1) return "fresh";
+  const hasPriorWork = !!context.githubPRUrl || !!context.claudeSessionId;
+  if (!hasPriorWork) return "fresh";
+  const messagesAfterAgent = context.chatHistory.slice(lastAgentIdx + 1);
+  const hasNewUserMessages = messagesAfterAgent.some((m) => m.role === "user");
+  return hasNewUserMessages ? "feedback_relaunch" : "idle_relaunch";
+}
+function buildRelaunchWithSession(mode, context) {
+  const scenario = detectRelaunchScenario(context);
+  if (!context.claudeSessionId || scenario === "fresh") return null;
+  const parts = [];
+  const lastAgentIdx = findLastAgentMessageIndex(context.chatHistory);
+  if (mode === "pm") {
+    const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
+    if (newMessages.length > 0) {
+      parts.push(
+        `You have been relaunched. Here are new messages since your last session:`,
+        ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`)
+      );
+    } else {
+      parts.push(`You have been relaunched. No new messages since your last session.`);
+    }
+    parts.push(
+      `
+You are the project manager for this task.`,
+      `Review the context above and wait for the team to provide instructions before taking action.`
+    );
+  } else if (scenario === "feedback_relaunch") {
+    const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
+    parts.push(
+      `You have been relaunched with new feedback.`,
+      `Work on the git branch "${context.githubBranch}".`,
+      `
+New messages since your last run:`,
+      ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
+      `
+Address the requested changes. Commit and push your updates.`
+    );
+    if (context.githubPRUrl) {
+      parts.push(
+        `An existing PR is open at ${context.githubPRUrl} \u2014 push to the same branch. Do NOT create a new PR.`
+      );
+    } else {
+      parts.push(
+        `When finished, use the create_pull_request tool to open a PR. Do NOT use gh CLI.`
+      );
+    }
+  } else {
+    parts.push(
+      `You were relaunched but no new instructions have been given since your last run.`,
+      `Work on the git branch "${context.githubBranch}".`,
+      `Review the current state of the codebase and verify everything is working correctly.`,
+      `Post a brief status update to the chat, then wait for further instructions.`
+    );
+    if (context.githubPRUrl) {
+      parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
+    }
+  }
+  return parts.join("\n");
+}
+function buildTaskBody(context) {
+  const parts = [];
+  parts.push(`# Task: ${context.title}`);
+  if (context.description) {
+    parts.push(`
+## Description
+${context.description}`);
+  }
+  if (context.plan) {
+    parts.push(`
+## Plan
+${context.plan}`);
+  }
+  if (context.files && context.files.length > 0) {
+    parts.push(`
+## Attached Files`);
+    for (const file of context.files) {
+      parts.push(`- **${file.fileName}** (${file.mimeType}): ${file.downloadUrl}`);
+    }
+  }
+  if (context.repoRefs && context.repoRefs.length > 0) {
+    parts.push(`
+## Repository References`);
+    for (const ref of context.repoRefs) {
+      const icon = ref.refType === "folder" ? "folder" : "file";
+      parts.push(`- [${icon}] \`${ref.path}\``);
+    }
+  }
+  if (context.chatHistory.length > 0) {
+    const relevant = context.chatHistory.slice(-20);
+    parts.push(`
+## Recent Chat Context`);
+    for (const msg of relevant) {
+      const sender = msg.userName ?? msg.role;
+      parts.push(`[${sender}]: ${msg.content}`);
+    }
+  }
+  return parts;
+}
+function buildInstructions(mode, context, scenario) {
+  const parts = [`
+## Instructions`];
+  const isPm = mode === "pm";
+  if (scenario === "fresh") {
+    if (isPm) {
+      parts.push(
+        `You are the project manager for this task.`,
+        `The task details are provided above. Wait for the team to ask questions or provide additional requirements before starting to plan.`
+      );
+    } else {
+      parts.push(
+        `Begin executing the task plan above immediately.`,
+        `Your FIRST action should be reading the relevant source files mentioned in the plan, then writing code. Do NOT run install, build, lint, test, or dev server commands first \u2014 the environment is already set up.`,
+        `Work on the git branch "${context.githubBranch}".`,
+        `Post a brief message to chat when you begin meaningful implementation, and again when the PR is ready.`,
+        `When finished, commit your changes, push the branch, and use the create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
+      );
+    }
+  } else if (scenario === "idle_relaunch") {
+    if (isPm) {
+      parts.push(
+        `You were relaunched but no new instructions have been given since your last run.`,
+        `You are the project manager for this task.`,
+        `Wait for the team to provide instructions before taking action.`
+      );
+    } else {
+      parts.push(
+        `You were relaunched but no new instructions have been given since your last run.`,
+        `Work on the git branch "${context.githubBranch}".`,
+        `Review the current state of the codebase and verify everything is working correctly (e.g. tests pass, the web server starts on port 3000).`,
+        `Post a brief status update to the chat summarizing the current state.`,
+        `Then wait for further instructions \u2014 do NOT redo work that was already completed.`
+      );
+      if (context.githubPRUrl) {
+        parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
+      }
+    }
+  } else {
+    const lastAgentIdx = findLastAgentMessageIndex(context.chatHistory);
+    const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
+    if (isPm) {
+      parts.push(
+        `You were relaunched with new feedback since your last run.`,
+        `You are the project manager for this task.`,
+        `
+New messages since your last run:`,
+        ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
+        `
+Review these messages and wait for the team to provide instructions before taking action.`
+      );
+    } else {
+      parts.push(
+        `You were relaunched with new feedback since your last run.`,
+        `Work on the git branch "${context.githubBranch}".`,
+        `
+New messages since your last run:`,
+        ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
+        `
+Address the requested changes. Commit and push your updates.`
+      );
+      if (context.githubPRUrl) {
+        parts.push(
+          `An existing PR is open at ${context.githubPRUrl} \u2014 push to the same branch to update it. Do NOT create a new PR.`
+        );
+      } else {
+        parts.push(
+          `When finished, use the create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
+        );
+      }
+    }
+  }
+  return parts;
+}
+function buildInitialPrompt(mode, context) {
+  const sessionRelaunch = buildRelaunchWithSession(mode, context);
+  if (sessionRelaunch) return sessionRelaunch;
+  const scenario = detectRelaunchScenario(context);
+  const body = buildTaskBody(context);
+  const instructions = buildInstructions(mode, context, scenario);
+  return [...body, ...instructions].join("\n");
+}
+function buildSystemPrompt(mode, context, config, setupLog) {
+  const isPm = mode === "pm";
+  const parts = isPm ? [
+    `You are an AI project manager helping to plan tasks for the "${context.title}" project.`,
+    `You are running locally with full access to the repository.`,
+    `
+Environment (ready, no setup required):`,
+    `- Repository is cloned at your current working directory.`,
+    `- You can read files to understand the codebase before writing task plans.`,
+    `- Check the dev branch (e.g. run: git fetch && git checkout dev || git checkout main) to understand the current state of the codebase that agents will branch off of.`
+  ] : [
+    `You are an AI agent working on a task for the "${context.title}" project.`,
+    `You are running inside a GitHub Codespace with full access to the repository.`,
+    `
+Environment (fully ready \u2014 do NOT verify or set up):`,
+    `- Repository is cloned at your current working directory.`,
+    `- Branch \`${context.githubBranch}\` is already checked out.`,
+    `- All dependencies are installed, database is migrated, and the dev server is running.`,
+    `- Git is configured. Commit and push directly to this branch.`,
+    `
+IMPORTANT \u2014 Skip all environment verification. Do NOT run any of the following:`,
+    `- bun/npm install, pip install, or any dependency installation`,
+    `- bun build, bun lint, bun test, bun typecheck, or any build/check commands as a "first step"`,
+    `- bun db:generate, bun db:push, prisma migrate, or any database setup`,
+    `- bun dev, npm start, or any dev server startup commands`,
+    `- pwd, ls, echo, or exploratory shell commands to "check" the environment`,
+    `Only run these if you encounter a specific error that requires it.`,
+    `Start reading the task plan and writing code immediately.`
+  ];
+  if (setupLog.length > 0) {
+    parts.push(
+      `
+Environment setup log (already executed before you started \u2014 proof that setup succeeded):`,
+      "```",
+      ...setupLog,
+      "```"
+    );
+  }
+  if (context.agentInstructions) {
+    parts.push(`
+Agent Instructions:
+${context.agentInstructions}`);
+  }
+  if (config.instructions) {
+    parts.push(`
+Additional Instructions:
+${config.instructions}`);
+  }
+  parts.push(
+    `
+You have access to Conveyor MCP tools to interact with the task management system.`,
+    `Use the post_to_chat tool to communicate progress or ask questions.`,
+    `Use the read_task_chat tool to check for new messages from the team.`
+  );
+  if (!isPm) {
+    parts.push(
+      `Use the create_pull_request tool to open PRs \u2014 do NOT use gh CLI or shell commands for PR creation.`
+    );
+  }
+  return parts.join("\n");
+}
+
+// src/mcp-tools.ts
+import { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+function buildCommonTools(connection, config) {
+  return [
+    tool(
+      "read_task_chat",
+      "Read recent messages from the task chat to see team feedback or instructions",
+      {
+        limit: z.number().optional().describe("Number of recent messages to fetch (default 20)")
+      },
+      async ({ limit }) => {
+        try {
+          const messages = await connection.fetchChatMessages(limit);
+          return textResult(JSON.stringify(messages, null, 2));
+        } catch {
+          return textResult(
+            JSON.stringify({
+              note: "Could not fetch live chat. Chat history was provided in the initial context."
+            })
+          );
+        }
+      },
+      { annotations: { readOnly: true } }
+    ),
+    tool(
+      "post_to_chat",
+      "Post a message to the task chat visible to all team members",
+      { message: z.string().describe("The message to post to the team") },
+      ({ message }) => {
+        connection.postChatMessage(message);
+        return Promise.resolve(textResult("Message posted to task chat."));
+      }
+    ),
+    tool(
+      "update_task_status",
+      "Update the task status on the Kanban board",
+      {
+        status: z.enum(["InProgress", "ReviewPR", "Complete"]).describe("The new status for the task")
+      },
+      ({ status }) => {
+        connection.updateStatus(status);
+        return Promise.resolve(textResult(`Task status updated to ${status}.`));
+      }
+    ),
+    tool(
+      "get_task_plan",
+      "Re-read the latest task plan in case it was updated",
+      {},
+      async () => {
+        try {
+          const ctx = await connection.fetchTaskContext();
+          return textResult(ctx.plan ?? "No plan available.");
+        } catch {
+          return textResult(`Task ID: ${config.taskId} - could not fetch updated plan.`);
+        }
+      },
+      { annotations: { readOnly: true } }
+    )
+  ];
+}
+function buildPmTools(connection) {
+  return [
+    tool(
+      "update_task",
+      "Save the finalized task plan and/or description",
+      {
+        plan: z.string().optional().describe("The task plan in markdown"),
+        description: z.string().optional().describe("Updated task description")
+      },
+      async ({ plan, description }) => {
+        try {
+          await Promise.resolve(connection.updateTaskFields({ plan, description }));
+          return textResult("Task updated successfully.");
+        } catch {
+          return textResult("Failed to update task.");
+        }
+      }
+    )
+  ];
+}
+function buildTaskTools(connection) {
+  return [
+    tool(
+      "create_pull_request",
+      "Create a GitHub pull request for this task. Use this instead of gh CLI or git commands to create PRs.",
+      {
+        title: z.string().describe("The PR title"),
+        body: z.string().describe("The PR description/body in markdown")
+      },
+      async ({ title, body }) => {
+        try {
+          const result = await connection.createPR({ title, body });
+          connection.sendEvent({
+            type: "pr_created",
+            url: result.url,
+            number: result.number
+          });
+          return textResult(`Pull request #${result.number} created: ${result.url}`);
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : "Unknown error";
+          return textResult(`Failed to create pull request: ${msg}`);
+        }
+      }
+    )
+  ];
+}
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function createConveyorMcpServer(connection, config) {
+  const commonTools = buildCommonTools(connection, config);
+  const modeTools = config.mode === "pm" ? buildPmTools(connection) : buildTaskTools(connection);
+  return createSdkMcpServer({
+    name: "conveyor",
+    tools: [...commonTools, ...modeTools]
+  });
+}
+
+// src/query-executor.ts
+var API_ERROR_PATTERN = /API Error: [45]\d\d/;
+var RETRY_DELAYS_MS = [6e4, 12e4, 18e4, 3e5];
+var PM_DENIED_TOOLS = /* @__PURE__ */ new Set([
+  "Write",
+  "Edit",
+  "MultiEdit",
+  "NotebookEdit",
+  "Bash",
+  "ExitPlanMode"
+]);
+async function processAssistantEvent(event, host, turnToolCalls) {
+  const msg = event.message;
+  const content = msg.content;
+  const turnTextParts = [];
+  for (const block of content) {
+    const blockType = block.type;
+    if (blockType === "text") {
+      const text = block.text;
+      turnTextParts.push(text);
+      host.connection.sendEvent({ type: "message", content: text });
+      await host.callbacks.onEvent({ type: "message", content: text });
+    } else if (blockType === "tool_use") {
+      const name = block.name;
+      const inputStr = typeof block.input === "string" ? block.input : JSON.stringify(block.input);
+      const isContentTool = ["edit", "write"].includes(name.toLowerCase());
+      const inputLimit = isContentTool ? 1e4 : 500;
+      const summary = {
+        tool: name,
+        input: inputStr.slice(0, inputLimit),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      turnToolCalls.push(summary);
+      host.connection.sendEvent({ type: "tool_use", tool: name, input: inputStr });
+      await host.callbacks.onEvent({ type: "tool_use", tool: name, input: inputStr });
+    }
+  }
+  if (turnTextParts.length > 0) {
+    host.connection.postChatMessage(turnTextParts.join("\n\n"));
+  }
+  if (turnToolCalls.length > 0) {
+    host.connection.sendEvent({ type: "turn_end", toolCalls: [...turnToolCalls] });
+    turnToolCalls.length = 0;
+  }
+  if (host.config.mode === "pm") {
+    host.syncPlanFile();
+  }
+}
+function handleResultEvent(event, host, context, startTime) {
+  const resultEvent = event;
+  let totalCostUsd = 0;
+  let retriable = false;
+  if (resultEvent.subtype === "success") {
+    totalCostUsd = "total_cost_usd" in resultEvent ? resultEvent.total_cost_usd : 0;
+    const durationMs = Date.now() - startTime;
+    const summary = "result" in resultEvent ? String(resultEvent.result) : "Task completed.";
+    if (API_ERROR_PATTERN.test(summary) && durationMs < 3e4) {
+      retriable = true;
+    }
+    host.connection.sendEvent({ type: "completed", summary, costUsd: totalCostUsd, durationMs });
+    if (totalCostUsd > 0 && context.agentId) {
+      const estimatedTotalTokens = Math.round(totalCostUsd * 1e5);
+      host.connection.trackSpending({
+        agentId: context.agentId,
+        inputTokens: Math.round(estimatedTotalTokens * 0.7),
+        outputTokens: Math.round(estimatedTotalTokens * 0.3),
+        totalTokens: estimatedTotalTokens,
+        totalCostUsd,
+        onSubscription: host.config.mode === "pm" || !!process.env.CLAUDE_CODE_OAUTH_TOKEN
+      });
+    }
+  } else {
+    const errors = "errors" in resultEvent ? resultEvent.errors : [];
+    const errorMsg = errors.length > 0 ? errors.join(", ") : `Agent stopped: ${resultEvent.subtype}`;
+    if (API_ERROR_PATTERN.test(errorMsg)) {
+      retriable = true;
+    }
+    host.connection.sendEvent({ type: "error", message: errorMsg });
+  }
+  return { totalCostUsd, retriable };
+}
+async function emitResultEvent(event, host, context, startTime) {
+  const result = handleResultEvent(event, host, context, startTime);
+  const durationMs = Date.now() - startTime;
+  if (result.totalCostUsd > 0 && context.agentId) {
+    await host.callbacks.onEvent({
+      type: "completed",
+      summary: "Task completed.",
+      costUsd: result.totalCostUsd,
+      durationMs
+    });
+  } else {
+    const resultEvent = event;
+    if (resultEvent.subtype === "success") {
+      const summary = "result" in resultEvent ? String(resultEvent.result) : "Task completed.";
+      await host.callbacks.onEvent({
+        type: "completed",
+        summary,
+        costUsd: 0,
+        durationMs
+      });
+    } else {
+      const errors = "errors" in resultEvent ? resultEvent.errors : [];
+      const errorMsg = errors.length > 0 ? errors.join(", ") : `Agent stopped: ${resultEvent.subtype}`;
+      await host.callbacks.onEvent({ type: "error", message: errorMsg });
+    }
+  }
+  return result.retriable;
+}
+async function processEvents(events, context, host) {
+  const startTime = Date.now();
+  let sessionIdStored = false;
+  let isTyping = false;
+  let retriable = false;
+  const turnToolCalls = [];
+  for await (const event of events) {
+    if (host.isStopped()) break;
+    switch (event.type) {
+      case "system": {
+        if (event.subtype === "init") {
+          const sessionId = event.session_id;
+          if (sessionId && !sessionIdStored) {
+            sessionIdStored = true;
+            host.connection.storeSessionId(sessionId);
+          }
+          await host.callbacks.onEvent({
+            type: "thinking",
+            message: `Agent initialized (model: ${event.model})`
+          });
+        }
+        break;
+      }
+      case "assistant": {
+        if (!isTyping) {
+          setTimeout(() => host.connection.sendTypingStart(), 200);
+          isTyping = true;
+        }
+        await processAssistantEvent(event, host, turnToolCalls);
+        break;
+      }
+      case "result": {
+        if (isTyping) {
+          host.connection.sendTypingStop();
+          isTyping = false;
+        }
+        retriable = await emitResultEvent(event, host, context, startTime);
+        break;
+      }
+    }
+  }
+  if (isTyping) {
+    host.connection.sendTypingStop();
+  }
+  return { retriable };
+}
+function buildCanUseTool(host) {
+  const QUESTION_TIMEOUT_MS = 5 * 60 * 1e3;
+  return async (toolName, input) => {
+    if (host.config.mode === "pm" && PM_DENIED_TOOLS.has(toolName)) {
+      return {
+        behavior: "deny",
+        message: "PM mode is plan-only. Use the update_task tool to save your plan."
+      };
+    }
+    if (toolName !== "AskUserQuestion") {
+      return { behavior: "allow", updatedInput: input };
+    }
+    const questions = input.questions;
+    const requestId = randomUUID();
+    host.connection.emitStatus("waiting_for_input");
+    host.connection.sendEvent({
+      type: "tool_use",
+      tool: "AskUserQuestion",
+      input: JSON.stringify(input)
+    });
+    const answerPromise = host.connection.askUserQuestion(requestId, questions);
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => resolve(null), QUESTION_TIMEOUT_MS);
+    });
+    const answers = await Promise.race([answerPromise, timeoutPromise]);
+    host.connection.emitStatus("running");
+    if (!answers) {
+      return {
+        behavior: "deny",
+        message: "User did not respond to clarifying questions in time. Proceed with your best judgment."
+      };
+    }
+    return { behavior: "allow", updatedInput: { questions: input.questions, answers } };
+  };
+}
+function buildQueryOptions(host, context) {
+  const settings = context.agentSettings ?? host.config.agentSettings ?? {};
+  const systemPromptText = buildSystemPrompt(host.config.mode, context, host.config, host.setupLog);
+  const conveyorMcp = createConveyorMcpServer(host.connection, host.config);
+  const isPm = host.config.mode === "pm";
+  const pmDisallowedTools = isPm ? ["TodoWrite", "TodoRead"] : [];
+  const disallowedTools = [...settings.disallowedTools ?? [], ...pmDisallowedTools];
+  const settingSources = settings.settingSources ?? ["user", "project"];
+  return {
+    model: context.model || host.config.model,
+    systemPrompt: {
+      type: "preset",
+      preset: "claude_code",
+      append: systemPromptText || void 0
+    },
+    settingSources,
+    cwd: host.config.workspaceDir,
+    permissionMode: isPm ? "plan" : "bypassPermissions",
+    allowDangerouslySkipPermissions: !isPm,
+    canUseTool: buildCanUseTool(host),
+    tools: { type: "preset", preset: "claude_code" },
+    mcpServers: { conveyor: conveyorMcp },
+    maxTurns: settings.maxTurns,
+    effort: settings.effort,
+    thinking: settings.thinking,
+    betas: settings.betas,
+    maxBudgetUsd: settings.maxBudgetUsd ?? 50,
+    disallowedTools: disallowedTools.length > 0 ? disallowedTools : void 0,
+    enableFileCheckpointing: settings.enableFileCheckpointing
+  };
+}
+async function runSdkQuery(host, context, followUpContent) {
+  if (host.isStopped()) return;
+  const isPm = host.config.mode === "pm";
+  if (isPm) {
+    host.snapshotPlanFiles();
+  }
+  const options = buildQueryOptions(host, context);
+  const resume = context.claudeSessionId ?? void 0;
+  if (followUpContent) {
+    const prompt = isPm ? `${buildInitialPrompt(host.config.mode, context)}
+
+---
+
+The team says:
+${followUpContent}` : followUpContent;
+    const agentQuery = query({ prompt, options: { ...options, resume } });
+    await runWithRetry(agentQuery, context, host, options);
+  } else if (isPm) {
+    return;
+  } else {
+    const initialPrompt = buildInitialPrompt(host.config.mode, context);
+    const agentQuery = query({
+      prompt: host.createInputStream(initialPrompt),
+      options: { ...options, resume }
+    });
+    await runWithRetry(agentQuery, context, host, options);
+  }
+  if (isPm) {
+    host.syncPlanFile();
+  }
+}
+async function runWithRetry(initialQuery, context, host, options) {
+  for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {
+    if (host.isStopped()) return;
+    const agentQuery = attempt === 0 ? initialQuery : query({
+      prompt: host.createInputStream(buildInitialPrompt(host.config.mode, context)),
+      options: { ...options, resume: void 0 }
+    });
+    try {
+      const { retriable } = await processEvents(agentQuery, context, host);
+      if (!retriable || host.isStopped()) return;
+    } catch (error) {
+      const isStaleSession = error instanceof Error && error.message.includes("No conversation found with session ID");
+      if (isStaleSession && context.claudeSessionId) {
+        host.connection.storeSessionId("");
+        const freshCtx = { ...context, claudeSessionId: null };
+        const freshQuery = query({
+          prompt: host.createInputStream(buildInitialPrompt(host.config.mode, freshCtx)),
+          options: { ...options, resume: void 0 }
+        });
+        return runWithRetry(freshQuery, freshCtx, host, options);
+      }
+      const isApiError = error instanceof Error && API_ERROR_PATTERN.test(error.message);
+      if (!isApiError) throw error;
+    }
+    if (attempt >= RETRY_DELAYS_MS.length) {
+      host.connection.postChatMessage(
+        `Agent shutting down after ${RETRY_DELAYS_MS.length} failed retry attempts due to API errors. The task will resume automatically when the codespace restarts.`
+      );
+      return;
+    }
+    const delayMs = RETRY_DELAYS_MS[attempt];
+    const delayMin = Math.round(delayMs / 6e4);
+    host.connection.postChatMessage(
+      `API error encountered. Retrying in ${delayMin} minute${delayMin > 1 ? "s" : ""}... (attempt ${attempt + 1}/${RETRY_DELAYS_MS.length})`
+    );
+    host.connection.sendEvent({
+      type: "error",
+      message: `API error, retrying in ${delayMin}m (${attempt + 1}/${RETRY_DELAYS_MS.length})`
+    });
+    host.connection.emitStatus("waiting_for_input");
+    await host.callbacks.onStatusChange("waiting_for_input");
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, delayMs);
+      const checkStopped = setInterval(() => {
+        if (host.isStopped()) {
+          clearTimeout(timer);
+          clearInterval(checkStopped);
+          resolve();
+        }
+      }, 1e3);
+      setTimeout(() => clearInterval(checkStopped), delayMs + 100);
+    });
+    host.connection.emitStatus("running");
+    await host.callbacks.onStatusChange("running");
+  }
+}
+
+// src/runner.ts
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var AgentRunner = class _AgentRunner {
+  config;
+  connection;
+  callbacks;
+  _state = "connecting";
+  stopped = false;
+  inputResolver = null;
+  pendingMessages = [];
+  setupLog = [];
+  heartbeatTimer = null;
+  taskContext = null;
+  planFileSnapshot = /* @__PURE__ */ new Map();
+  worktreeActive = false;
+  static MAX_SETUP_LOG_LINES = 50;
+  constructor(config, callbacks) {
+    this.config = config;
+    this.connection = new ConveyorConnection(config);
+    this.callbacks = callbacks;
+  }
+  get state() {
+    return this._state;
+  }
+  async setState(status) {
+    this._state = status;
+    this.connection.emitStatus(status);
+    await this.callbacks.onStatusChange(status);
+  }
+  startHeartbeat() {
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.stopped) {
+        this.connection.sendHeartbeat();
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  async start() {
+    await this.setState("connecting");
+    await this.connection.connect();
+    this.connection.onStopRequested(() => this.stop());
+    this.connection.onChatMessage((message) => this.injectHumanMessage(message.content));
+    await this.setState("connected");
+    this.connection.sendEvent({ type: "connected", taskId: this.config.taskId });
+    this.startHeartbeat();
+    if (this.config.mode !== "pm" && process.env.CODESPACES === "true") {
+      const setupOk = await this.runSetupSafe();
+      if (!setupOk) {
+        this.stopHeartbeat();
+        await this.setState("error");
+        this.connection.disconnect();
+        return;
+      }
+    }
+    this.initRtk();
+    if (this.config.mode === "pm" || process.env.CONVEYOR_USE_WORKTREE === "true") {
+      try {
+        const worktreePath = ensureWorktree(this.config.workspaceDir, this.config.taskId);
+        this.config = { ...this.config, workspaceDir: worktreePath };
+        this.worktreeActive = true;
+        this.setupLog.push(`[conveyor] Using worktree: ${worktreePath}`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : "Unknown error";
+        this.setupLog.push(`[conveyor] Worktree creation failed, using shared workspace: ${msg}`);
+      }
+    }
+    await this.setState("fetching_context");
+    try {
+      this.taskContext = await this.connection.fetchTaskContext();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to fetch task context";
+      this.connection.sendEvent({ type: "error", message });
+      await this.callbacks.onEvent({ type: "error", message });
+      this.stopHeartbeat();
+      await this.setState("error");
+      this.connection.disconnect();
+      return;
+    }
+    if (process.env.CODESPACES === "true" && this.taskContext.baseBranch) {
+      const result = cleanDevcontainerFromGit(
+        this.config.workspaceDir,
+        this.taskContext.githubBranch,
+        this.taskContext.baseBranch
+      );
+      if (result.cleaned) {
+        this.setupLog.push(`[conveyor] ${result.message}`);
+      }
+    }
+    if (!this.worktreeActive && this.taskContext.useWorktree) {
+      try {
+        const worktreePath = ensureWorktree(this.config.workspaceDir, this.config.taskId);
+        this.config = { ...this.config, workspaceDir: worktreePath };
+        this.worktreeActive = true;
+        this.setupLog.push(`[conveyor] Using worktree (from task config): ${worktreePath}`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : "Unknown error";
+        this.setupLog.push(`[conveyor] Worktree creation failed, using shared workspace: ${msg}`);
+      }
+    }
+    if (this.worktreeActive && this.taskContext.githubBranch) {
+      try {
+        const branch = this.taskContext.githubBranch;
+        execSync3(`git fetch origin ${branch} && git checkout ${branch}`, {
+          cwd: this.config.workspaceDir,
+          stdio: "ignore"
+        });
+      } catch {
+      }
+    }
+    const isPm = this.config.mode === "pm";
+    if (isPm) {
+      await this.setState("idle");
+    } else {
+      await this.setState("running");
+      await runSdkQuery(this.asQueryHost(), this.taskContext);
+      if (!this.stopped) await this.setState("idle");
+    }
+    await this.runCoreLoop();
+    this.stopHeartbeat();
+    await this.setState("finished");
+    this.connection.disconnect();
+  }
+  async runCoreLoop() {
+    if (!this.taskContext) return;
+    while (!this.stopped) {
+      if (this._state === "idle") {
+        const msg = await this.waitForUserContent();
+        if (!msg) break;
+        await this.setState("running");
+        await runSdkQuery(this.asQueryHost(), this.taskContext, msg);
+        if (!this.stopped) await this.setState("idle");
+      } else if (this._state === "error") {
+        await this.setState("idle");
+      } else {
+        break;
+      }
+    }
+  }
+  async runSetupSafe() {
+    await this.setState("setup");
+    const ports = await loadForwardPorts(this.config.workspaceDir);
+    if (ports.length > 0 && process.env.CODESPACE_NAME) {
+      const visibility = ports.map((p) => `${p}:public`).join(" ");
+      runStartCommand(
+        `gh codespace ports visibility ${visibility} -c "${process.env.CODESPACE_NAME}" 2>/dev/null`,
+        this.config.workspaceDir,
+        () => void 0
+      );
+    }
+    const config = await loadConveyorConfig(this.config.workspaceDir);
+    if (!config) {
+      this.connection.sendEvent({ type: "setup_complete" });
+      await this.callbacks.onEvent({ type: "setup_complete" });
+      return true;
+    }
+    try {
+      await this.executeSetupConfig(config);
+      const setupEvent = {
+        type: "setup_complete",
+        previewPort: config.previewPort ?? void 0
+      };
+      this.connection.sendEvent(setupEvent);
+      await this.callbacks.onEvent(setupEvent);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Setup failed";
+      this.connection.sendEvent({ type: "setup_error", message });
+      await this.callbacks.onEvent({ type: "setup_error", message });
+      this.connection.postChatMessage(
+        `Environment setup failed: ${message}
+The agent cannot start until this is resolved.`
+      );
+      return false;
+    }
+  }
+  pushSetupLog(line) {
+    this.setupLog.push(line);
+    if (this.setupLog.length > _AgentRunner.MAX_SETUP_LOG_LINES) {
+      this.setupLog.splice(0, this.setupLog.length - _AgentRunner.MAX_SETUP_LOG_LINES);
+    }
+  }
+  async executeSetupConfig(config) {
+    if (config.setupCommand) {
+      this.pushSetupLog(`$ ${config.setupCommand}`);
+      await runSetupCommand(config.setupCommand, this.config.workspaceDir, (stream, data) => {
+        this.connection.sendEvent({ type: "setup_output", stream, data });
+        for (const line of data.split("\n").filter(Boolean)) {
+          this.pushSetupLog(`[${stream}] ${line}`);
+        }
+      });
+      this.pushSetupLog("(exit 0)");
+    }
+    if (config.startCommand) {
+      this.pushSetupLog(`$ ${config.startCommand} &  (background)`);
+      runStartCommand(config.startCommand, this.config.workspaceDir, (stream, data) => {
+        this.connection.sendEvent({ type: "start_command_output", stream, data });
+      });
+    }
+  }
+  initRtk() {
+    try {
+      execSync3("rtk --version", { stdio: "ignore" });
+      execSync3("rtk init --global --auto-patch", { stdio: "ignore" });
+    } catch {
+    }
+  }
+  injectHumanMessage(content) {
+    const msg = {
+      type: "user",
+      session_id: "",
+      message: { role: "user", content },
+      parent_tool_use_id: null
+    };
+    if (this.inputResolver) {
+      const resolve = this.inputResolver;
+      this.inputResolver = null;
+      resolve(msg);
+    } else {
+      this.pendingMessages.push(msg);
+    }
+  }
+  waitForMessage() {
+    return new Promise((resolve) => {
+      const checkStopped = setInterval(() => {
+        if (this.stopped) {
+          clearInterval(checkStopped);
+          this.inputResolver = null;
+          resolve(null);
+        }
+      }, 1e3);
+      this.inputResolver = (msg) => {
+        clearInterval(checkStopped);
+        resolve(msg);
+      };
+    });
+  }
+  async waitForUserContent() {
+    if (this.pendingMessages.length > 0) {
+      const next = this.pendingMessages.shift();
+      return next?.message?.content ?? null;
+    }
+    const msg = await this.waitForMessage();
+    if (!msg) return null;
+    return msg.message.content;
+  }
+  async *createInputStream(initialPrompt) {
+    const makeUserMessage = (content) => ({
+      type: "user",
+      session_id: "",
+      message: { role: "user", content },
+      parent_tool_use_id: null
+    });
+    yield makeUserMessage(initialPrompt);
+    while (!this.stopped) {
+      if (this.pendingMessages.length > 0) {
+        const next = this.pendingMessages.shift();
+        if (next) yield next;
+        continue;
+      }
+      this.connection.emitStatus("waiting_for_input");
+      await this.callbacks.onStatusChange("waiting_for_input");
+      const msg = await this.waitForMessage();
+      if (!msg) break;
+      this.connection.emitStatus("running");
+      await this.callbacks.onStatusChange("running");
+      yield msg;
+    }
+  }
+  /**
+   * Snapshot current plan files so syncPlanFile can distinguish files created
+   * by THIS session from ones created by a concurrent agent.
+   */
+  snapshotPlanFiles() {
+    const plansDir = join3(homedir(), ".claude", "plans");
+    this.planFileSnapshot.clear();
+    try {
+      for (const file of readdirSync(plansDir).filter((f) => f.endsWith(".md"))) {
+        try {
+          const stat = statSync(join3(plansDir, file));
+          this.planFileSnapshot.set(file, stat.mtimeMs);
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+    }
+  }
+  syncPlanFile() {
+    const plansDir = join3(homedir(), ".claude", "plans");
+    let files;
+    try {
+      files = readdirSync(plansDir).filter((f) => f.endsWith(".md"));
+    } catch {
+      return;
+    }
+    let newest = null;
+    for (const file of files) {
+      const fullPath = join3(plansDir, file);
+      try {
+        const stat = statSync(fullPath);
+        const prevMtime = this.planFileSnapshot.get(file);
+        const isNew = prevMtime === void 0 || stat.mtimeMs > prevMtime;
+        if (isNew && (!newest || stat.mtimeMs > newest.mtime)) {
+          newest = { path: fullPath, mtime: stat.mtimeMs };
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (newest) {
+      const content = readFileSync(newest.path, "utf-8").trim();
+      if (content) {
+        this.connection.updateTaskFields({ plan: content });
+      }
+    }
+  }
+  asQueryHost() {
+    return {
+      config: this.config,
+      connection: this.connection,
+      callbacks: this.callbacks,
+      setupLog: this.setupLog,
+      isStopped: () => this.stopped,
+      createInputStream: (prompt) => this.createInputStream(prompt),
+      snapshotPlanFiles: () => this.snapshotPlanFiles(),
+      syncPlanFile: () => this.syncPlanFile()
+    };
+  }
+  stop() {
+    this.stopped = true;
+    if (this.inputResolver) {
+      this.inputResolver(null);
+      this.inputResolver = null;
+    }
+  }
+};
+
+export {
+  ConveyorConnection,
+  loadConveyorConfig,
+  runSetupCommand,
+  runStartCommand,
+  ensureWorktree,
+  removeWorktree,
+  AgentRunner
+};
+//# sourceMappingURL=chunk-42BYQ6YY.js.map