@rallycry/conveyor-agent 2.7.0 → 2.8.0

package/dist/chunk-JWIGEYRD.js

@@ -1,1397 +0,0 @@
-// 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 { randomUUID } from "crypto";
-import { execSync as execSync3 } from "child_process";
-import { readdirSync, statSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join as join3 } from "path";
-import {
-  query,
-  tool,
-  createSdkMcpServer
-} from "@anthropic-ai/claude-agent-sdk";
-import { z } from "zod";
-var API_ERROR_PATTERN = /API Error: [45]\d\d/;
-var RETRY_DELAYS_MS = [6e4, 12e4, 18e4, 3e5];
-var HEARTBEAT_INTERVAL_MS = 3e4;
-var PM_DENIED_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit", "NotebookEdit", "Bash"]);
-var AgentRunner = class _AgentRunner {
-  config;
-  connection;
-  callbacks;
-  _state = "connecting";
-  stopped = false;
-  inputResolver = null;
-  pendingMessages = [];
-  currentTurnToolCalls = [];
-  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;
-    }
-  }
-  // oxlint-disable-next-line max-lines-per-function
-  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 this.runSdkQuery(this.taskContext);
-      if (!this.stopped) {
-        await this.setState("idle");
-      }
-    }
-    while (!this.stopped) {
-      if (this._state === "idle") {
-        const msg = await this.waitForUserContent();
-        if (!msg) break;
-        await this.setState("running");
-        await this.runSdkQuery(this.taskContext, msg);
-        if (!this.stopped) {
-          await this.setState("idle");
-        }
-      } else if (this._state === "error") {
-        await this.setState("idle");
-      } else {
-        break;
-      }
-    }
-    this.stopHeartbeat();
-    await this.setState("finished");
-    this.connection.disconnect();
-  }
-  /**
-   * Wraps project setup in try/catch. On failure, posts error to chat
-   * directly (no SDK needed) and streams to CLI. Returns false if setup failed.
-   */
-  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);
-      };
-    });
-  }
-  /**
-   * Wait for the next user message content string. Drains pendingMessages first.
-   * Returns null if stopped.
-   */
-  async waitForUserContent() {
-    if (this.pendingMessages.length > 0) {
-      const next = this.pendingMessages.shift();
-      return next.message.content;
-    }
-    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;
-    }
-  }
-  findLastAgentMessageIndex(history) {
-    for (let i = history.length - 1; i >= 0; i--) {
-      if (history[i].role === "assistant") return i;
-    }
-    return -1;
-  }
-  detectRelaunchScenario(context) {
-    const lastAgentIdx = this.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";
-  }
-  // eslint-disable-next-line max-lines-per-function
-  buildInitialPrompt(context) {
-    const parts = [];
-    const scenario = this.detectRelaunchScenario(context);
-    if (context.claudeSessionId && scenario !== "fresh") {
-      if (this.config.mode === "pm") {
-        const lastAgentIdx = this.findLastAgentMessageIndex(context.chatHistory);
-        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 lastAgentIdx = this.findLastAgentMessageIndex(context.chatHistory);
-        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");
-    }
-    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}`);
-      }
-    }
-    parts.push(`
-## Instructions`);
-    if (scenario === "fresh") {
-      if (this.config.mode === "pm") {
-        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 (this.config.mode === "pm") {
-        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 = this.findLastAgentMessageIndex(context.chatHistory);
-      const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
-      if (this.config.mode === "pm") {
-        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.join("\n");
-  }
-  buildSystemPrompt(context) {
-    const parts = this.config.mode === "pm" ? [
-      `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 (this.setupLog.length > 0) {
-      parts.push(
-        `
-Environment setup log (already executed before you started \u2014 proof that setup succeeded):`,
-        "```",
-        ...this.setupLog,
-        "```"
-      );
-    }
-    if (context.agentInstructions) {
-      parts.push(`
-Agent Instructions:
-${context.agentInstructions}`);
-    }
-    if (this.config.instructions) {
-      parts.push(`
-Additional Instructions:
-${this.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 (this.config.mode !== "pm") {
-      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");
-  }
-  // oxlint-disable-next-line typescript/explicit-function-return-type, max-lines-per-function
-  createConveyorMcpServer(context) {
-    const connection = this.connection;
-    const config = this.config;
-    const textResult = (text) => ({
-      content: [{ type: "text", text }]
-    });
-    const commonTools = [
-      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 } }
-      )
-    ];
-    const modeTools = config.mode === "pm" ? [
-      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 {
-            connection.updateTaskFields({ plan, description });
-            return textResult("Task updated successfully.");
-          } catch {
-            return textResult("Failed to update task.");
-          }
-        }
-      )
-    ] : [
-      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}`);
-          }
-        }
-      )
-    ];
-    return createSdkMcpServer({
-      name: "conveyor",
-      tools: [...commonTools, ...modeTools]
-    });
-    void context;
-  }
-  // oxlint-disable-next-line max-lines-per-function, complexity
-  async processEvents(events, context) {
-    const startTime = Date.now();
-    let totalCostUsd = 0;
-    let sessionIdStored = false;
-    let isTyping = false;
-    let retriable = false;
-    for await (const event of events) {
-      if (this.stopped) break;
-      switch (event.type) {
-        case "system": {
-          if (event.subtype === "init") {
-            const sessionId = event.session_id;
-            if (sessionId && !sessionIdStored) {
-              sessionIdStored = true;
-              this.connection.storeSessionId(sessionId);
-            }
-            await this.callbacks.onEvent({
-              type: "thinking",
-              message: `Agent initialized (model: ${event.model})`
-            });
-          }
-          break;
-        }
-        case "assistant": {
-          if (!isTyping) {
-            setTimeout(() => {
-              this.connection.sendTypingStart();
-            }, 200);
-            isTyping = true;
-          }
-          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);
-              this.connection.sendEvent({ type: "message", content: text });
-              await this.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()
-              };
-              this.currentTurnToolCalls.push(summary);
-              this.connection.sendEvent({
-                type: "tool_use",
-                tool: name,
-                input: inputStr
-              });
-              await this.callbacks.onEvent({
-                type: "tool_use",
-                tool: name,
-                input: inputStr
-              });
-            }
-          }
-          if (turnTextParts.length > 0) {
-            this.connection.postChatMessage(turnTextParts.join("\n\n"));
-          }
-          if (this.currentTurnToolCalls.length > 0) {
-            this.connection.sendEvent({
-              type: "turn_end",
-              toolCalls: [...this.currentTurnToolCalls]
-            });
-            this.currentTurnToolCalls = [];
-          }
-          if (this.config.mode === "pm") {
-            this.syncPlanFile();
-          }
-          break;
-        }
-        case "result": {
-          if (isTyping) {
-            this.connection.sendTypingStop();
-            isTyping = false;
-          }
-          const resultEvent = event;
-          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;
-            }
-            this.connection.sendEvent({
-              type: "completed",
-              summary,
-              costUsd: totalCostUsd,
-              durationMs
-            });
-            if (totalCostUsd > 0 && context.agentId) {
-              const estimatedTotalTokens = Math.round(totalCostUsd * 1e5);
-              const estimatedInputTokens = Math.round(estimatedTotalTokens * 0.7);
-              const estimatedOutputTokens = Math.round(estimatedTotalTokens * 0.3);
-              this.connection.trackSpending({
-                agentId: context.agentId,
-                inputTokens: estimatedInputTokens,
-                outputTokens: estimatedOutputTokens,
-                totalTokens: estimatedTotalTokens,
-                totalCostUsd,
-                onSubscription: this.config.mode === "pm" || !!process.env.CLAUDE_CODE_OAUTH_TOKEN
-              });
-            }
-            await this.callbacks.onEvent({
-              type: "completed",
-              summary,
-              costUsd: totalCostUsd,
-              durationMs
-            });
-          } 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;
-            }
-            this.connection.sendEvent({ type: "error", message: errorMsg });
-            await this.callbacks.onEvent({ type: "error", message: errorMsg });
-          }
-          break;
-        }
-      }
-    }
-    if (isTyping) {
-      this.connection.sendTypingStop();
-    }
-    return { retriable };
-  }
-  /**
-   * 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 {
-    }
-  }
-  /**
-   * After a PM-mode query, scan ~/.claude/plans/ for plan files that were
-   * created or modified by THIS session (not present in the pre-query snapshot)
-   * and push the newest one to the task.
-   */
-  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 });
-      }
-    }
-  }
-  /**
-   * Runs one SDK query cycle. For PM mode this is a single-turn query per
-   * user message. For task mode this uses the long-running input stream
-   * (initial execution) or a single follow-up prompt.
-   */
-  // oxlint-disable-next-line max-lines-per-function
-  async runSdkQuery(context, followUpContent) {
-    if (this.stopped) return;
-    const settings = context.agentSettings ?? this.config.agentSettings ?? {};
-    const systemPromptText = this.buildSystemPrompt(context);
-    const conveyorMcp = this.createConveyorMcpServer(context);
-    const systemPrompt = {
-      type: "preset",
-      preset: "claude_code",
-      append: systemPromptText || void 0
-    };
-    const settingSources = settings.settingSources ?? ["user", "project"];
-    const model = context.model || this.config.model;
-    const pmDisallowedTools = this.config.mode === "pm" ? ["TodoWrite", "TodoRead"] : [];
-    const disallowedTools = [...settings.disallowedTools ?? [], ...pmDisallowedTools];
-    const isPm = this.config.mode === "pm";
-    if (isPm) {
-      this.snapshotPlanFiles();
-    }
-    const QUESTION_TIMEOUT_MS = 5 * 60 * 1e3;
-    const canUseTool = async (toolName, input) => {
-      if (toolName === "AskUserQuestion") {
-        const questions = input.questions;
-        const requestId = randomUUID();
-        this.connection.emitStatus("waiting_for_input");
-        this.connection.sendEvent({
-          type: "tool_use",
-          tool: "AskUserQuestion",
-          input: JSON.stringify(input)
-        });
-        const answerPromise = this.connection.askUserQuestion(requestId, questions);
-        const timeoutPromise = new Promise(
-          (resolve) => setTimeout(() => resolve(null), QUESTION_TIMEOUT_MS)
-        );
-        const answers = await Promise.race([answerPromise, timeoutPromise]);
-        this.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 }
-        };
-      }
-      if (isPm && PM_DENIED_TOOLS.has(toolName)) {
-        return {
-          behavior: "deny",
-          message: "PM mode is plan-only. Use the update_task tool to save your plan."
-        };
-      }
-      return { behavior: "allow", updatedInput: input };
-    };
-    const commonOptions = {
-      model,
-      systemPrompt,
-      settingSources,
-      cwd: this.config.workspaceDir,
-      permissionMode: isPm ? "plan" : "bypassPermissions",
-      allowDangerouslySkipPermissions: !isPm,
-      canUseTool,
-      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
-    };
-    const resume = context.claudeSessionId ?? void 0;
-    if (followUpContent) {
-      const prompt = isPm ? `${this.buildInitialPrompt(context)}
-
----
-
-The team says:
-${followUpContent}` : followUpContent;
-      const agentQuery = query({
-        prompt,
-        options: { ...commonOptions, resume }
-      });
-      await this.runWithRetry(agentQuery, context, commonOptions);
-    } else if (isPm) {
-      return;
-    } else {
-      const initialPrompt = this.buildInitialPrompt(context);
-      const agentQuery = query({
-        prompt: this.createInputStream(initialPrompt),
-        options: { ...commonOptions, resume }
-      });
-      await this.runWithRetry(agentQuery, context, commonOptions);
-    }
-    if (isPm) {
-      this.syncPlanFile();
-    }
-  }
-  /**
-   * Run a query with retry logic for transient API errors.
-   */
-  async runWithRetry(initialQuery, context, options) {
-    for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {
-      if (this.stopped) return;
-      const agentQuery = attempt === 0 ? initialQuery : query({
-        prompt: this.createInputStream(this.buildInitialPrompt(context)),
-        options: { ...options, resume: void 0 }
-      });
-      try {
-        const { retriable } = await this.processEvents(agentQuery, context);
-        if (!retriable || this.stopped) return;
-      } catch (error) {
-        const isStaleSession = error instanceof Error && error.message.includes("No conversation found with session ID");
-        if (isStaleSession && context.claudeSessionId) {
-          this.connection.storeSessionId("");
-          const freshCtx = { ...context, claudeSessionId: null };
-          const freshQuery = query({
-            prompt: this.createInputStream(this.buildInitialPrompt(freshCtx)),
-            options: { ...options, resume: void 0 }
-          });
-          return this.runWithRetry(freshQuery, freshCtx, options);
-        }
-        const isApiError = error instanceof Error && API_ERROR_PATTERN.test(error.message);
-        if (!isApiError) throw error;
-      }
-      if (attempt >= RETRY_DELAYS_MS.length) {
-        this.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);
-      this.connection.postChatMessage(
-        `API error encountered. Retrying in ${delayMin} minute${delayMin > 1 ? "s" : ""}... (attempt ${attempt + 1}/${RETRY_DELAYS_MS.length})`
-      );
-      this.connection.sendEvent({
-        type: "error",
-        message: `API error, retrying in ${delayMin}m (${attempt + 1}/${RETRY_DELAYS_MS.length})`
-      });
-      this.connection.emitStatus("waiting_for_input");
-      await this.callbacks.onStatusChange("waiting_for_input");
-      await new Promise((resolve) => {
-        const timer = setTimeout(resolve, delayMs);
-        const checkStopped = setInterval(() => {
-          if (this.stopped) {
-            clearTimeout(timer);
-            clearInterval(checkStopped);
-            resolve();
-          }
-        }, 1e3);
-        setTimeout(() => clearInterval(checkStopped), delayMs + 100);
-      });
-      this.connection.emitStatus("running");
-      await this.callbacks.onStatusChange("running");
-    }
-  }
-  stop() {
-    this.stopped = true;
-    if (this.inputResolver) {
-      this.inputResolver(null);
-      this.inputResolver = null;
-    }
-  }
-};
-
-export {
-  ConveyorConnection,
-  loadConveyorConfig,
-  runSetupCommand,
-  runStartCommand,
-  ensureWorktree,
-  removeWorktree,
-  AgentRunner
-};
-//# sourceMappingURL=chunk-JWIGEYRD.js.map