@rallycry/conveyor-agent 2.12.0 → 2.14.0

package/dist/{chunk-WD6A5AYJ.js → chunk-KFCGF2SX.js}

@@ -15,7 +15,7 @@ var ConveyorConnection = class _ConveyorConnection {
     this.config = config;
   }
   connect() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let settled = false;
       let attempts = 0;
       const maxInitialAttempts = 30;
@@ -61,7 +61,7 @@ var ConveyorConnection = class _ConveyorConnection {
       this.socket.on("connect", () => {
         if (!settled) {
           settled = true;
-          resolve();
+          resolve2();
         }
       });
       this.socket.io.on("reconnect_attempt", () => {
@@ -76,13 +76,13 @@ var ConveyorConnection = class _ConveyorConnection {
   fetchChatMessages(limit) {
     const socket = this.socket;
     if (!socket) throw new Error("Not connected");
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       socket.emit(
         "agentRunner:getChatMessages",
         { taskId: this.config.taskId, limit },
         (response) => {
           if (response.success && response.data) {
-            resolve(response.data);
+            resolve2(response.data);
           } else {
             reject(new Error(response.error ?? "Failed to fetch chat messages"));
           }
@@ -93,13 +93,13 @@ var ConveyorConnection = class _ConveyorConnection {
   fetchTaskContext() {
     const socket = this.socket;
     if (!socket) throw new Error("Not connected");
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       socket.emit(
         "agentRunner:getTaskContext",
         { taskId: this.config.taskId },
         (response) => {
           if (response.success && response.data) {
-            resolve(response.data);
+            resolve2(response.data);
           } else {
             reject(new Error(response.error ?? "Failed to fetch task context"));
           }
@@ -142,13 +142,13 @@ var ConveyorConnection = class _ConveyorConnection {
   createPR(params) {
     const socket = this.socket;
     if (!socket) throw new Error("Not connected");
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       socket.emit(
         "agentRunner:createPR",
         { taskId: this.config.taskId, ...params },
         (response) => {
           if (response.success && response.data) {
-            resolve(response.data);
+            resolve2(response.data);
           } else {
             reject(new Error(response.error ?? "Failed to create pull request"));
           }
@@ -163,8 +163,8 @@ var ConveyorConnection = class _ConveyorConnection {
       requestId,
       questions
     });
-    return new Promise((resolve) => {
-      this.pendingQuestionResolvers.set(requestId, resolve);
+    return new Promise((resolve2) => {
+      this.pendingQuestionResolvers.set(requestId, resolve2);
     });
   }
   cancelPendingQuestions() {
@@ -224,6 +224,45 @@ var ConveyorConnection = class _ConveyorConnection {
   sendTypingStop() {
     this.sendEvent({ type: "agent_typing_stop" });
   }
+  createSubtask(data) {
+    const socket = this.socket;
+    if (!socket) throw new Error("Not connected");
+    return new Promise((resolve2, reject) => {
+      socket.emit(
+        "agentRunner:createSubtask",
+        data,
+        (response) => {
+          if (response.success && response.data) resolve2(response.data);
+          else reject(new Error(response.error ?? "Failed to create subtask"));
+        }
+      );
+    });
+  }
+  updateSubtask(subtaskId, fields) {
+    if (!this.socket) throw new Error("Not connected");
+    this.socket.emit("agentRunner:updateSubtask", {
+      subtaskId,
+      fields
+    });
+  }
+  deleteSubtask(subtaskId) {
+    if (!this.socket) throw new Error("Not connected");
+    this.socket.emit("agentRunner:deleteSubtask", { subtaskId });
+  }
+  listSubtasks() {
+    const socket = this.socket;
+    if (!socket) throw new Error("Not connected");
+    return new Promise((resolve2, reject) => {
+      socket.emit(
+        "agentRunner:listSubtasks",
+        {},
+        (response) => {
+          if (response.success && response.data) resolve2(response.data);
+          else reject(new Error(response.error ?? "Failed to list subtasks"));
+        }
+      );
+    });
+  }
   disconnect() {
     this.flushEvents();
     this.socket?.disconnect();
@@ -265,7 +304,7 @@ async function loadConveyorConfig(workspaceDir) {
   return null;
 }
 function runSetupCommand(cmd, cwd, onOutput) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const child = spawn("sh", ["-c", cmd], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -279,7 +318,7 @@ function runSetupCommand(cmd, cwd, onOutput) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve();
+        resolve2();
       } else {
         reject(new Error(`Setup command exited with code ${code}`));
       }
@@ -385,6 +424,7 @@ import { randomUUID } from "crypto";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
 // src/prompt-builder.ts
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["InProgress", "ReviewPR", "ReviewDev", "ReviewLive"]);
 function findLastAgentMessageIndex(history) {
   for (let i = history.length - 1; i >= 0; i--) {
     if (history[i].role === "assistant") return i;
@@ -394,7 +434,7 @@ function findLastAgentMessageIndex(history) {
 function detectRelaunchScenario(context) {
   const lastAgentIdx = findLastAgentMessageIndex(context.chatHistory);
   if (lastAgentIdx === -1) return "fresh";
-  const hasPriorWork = !!context.githubPRUrl || !!context.claudeSessionId;
+  const hasPriorWork = !!context.githubPRUrl || !!context.claudeSessionId || ACTIVE_STATUSES.has(context.status ?? "");
   if (!hasPriorWork) return "fresh";
   const messagesAfterAgent = context.chatHistory.slice(lastAgentIdx + 1);
   const hasNewUserMessages = messagesAfterAgent.some((m) => m.role === "user");
@@ -424,12 +464,13 @@ You are the project manager for this task.`,
     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}".`,
+      `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
       `
 New messages since your last run:`,
       ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
       `
-Address the requested changes. Commit and push your updates.`
+Address the requested changes. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 review the feedback and implement the changes directly.`,
+      `Commit and push your updates.`
     );
     if (context.githubPRUrl) {
       parts.push(
@@ -443,7 +484,8 @@ Address the requested changes. Commit and push your updates.`
   } else {
     parts.push(
       `You were relaunched but no new instructions have been given since your last run.`,
-      `Work on the git branch "${context.githubBranch}".`,
+      `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+      `Run \`git log --oneline -10\` to review what you already committed.`,
       `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.`
     );
@@ -515,7 +557,7 @@ function buildInstructions(mode, context, scenario) {
       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}".`,
+        `Work on the git branch "${context.githubBranch}". Stay on this branch for the entire task. Do not checkout or create other branches.`,
         `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.`
       );
@@ -530,9 +572,9 @@ function buildInstructions(mode, context, scenario) {
     } 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.`,
+        `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+        `Run \`git log --oneline -10\` to review what you already committed, then verify the current state is correct.`,
+        `Post a brief status update to the chat summarizing where things stand.`,
         `Then wait for further instructions \u2014 do NOT redo work that was already completed.`
       );
       if (context.githubPRUrl) {
@@ -554,13 +596,15 @@ Review these messages and wait for the team to provide instructions before takin
       );
     } else {
       parts.push(
-        `You were relaunched with new feedback since your last run.`,
-        `Work on the git branch "${context.githubBranch}".`,
+        `You have been relaunched to address feedback on your previous work.`,
+        `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+        `Start by running \`git log --oneline -10\` and \`git diff HEAD~3 HEAD --stat\` to review what you already committed.`,
         `
 New messages since your last run:`,
         ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
         `
-Address the requested changes. Commit and push your updates.`
+Address the requested changes directly. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 go straight to implementing the feedback.`,
+        `Commit and push your updates.`
       );
       if (context.githubPRUrl) {
         parts.push(
@@ -596,8 +640,9 @@ Environment (ready, no setup required):`,
     `- 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.`,
     `
 Workflow:`,
-    `- When you have a complete plan, save it using the update_task tool and post a summary to chat.`,
-    `- After saving the plan, end your turn. Do NOT attempt to execute the plan yourself.`,
+    `- You can draft and iterate on plans in .claude/plans/*.md \u2014 these files are automatically synced to the task.`,
+    `- You can also use update_task directly to save the plan to the task.`,
+    `- After saving the plan, post a summary to chat and end your turn. Do NOT attempt to execute the plan yourself.`,
     `- A separate task agent will handle execution after the team reviews and approves your plan.`
   ] : [
     `You are an AI agent working on a task for the "${context.title}" project.`,
@@ -616,7 +661,14 @@ IMPORTANT \u2014 Skip all environment verification. Do NOT run any of the follow
     `- 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.`
+    `Start reading the task plan and writing code immediately.`,
+    `
+Git safety \u2014 STRICT rules:`,
+    `- NEVER run \`git checkout main\`, \`git checkout dev\`, or switch to any branch other than \`${context.githubBranch}\`.`,
+    `- NEVER create new branches (no \`git checkout -b\`, \`git switch -c\`, etc.).`,
+    `- This branch was created from \`${context.baseBranch}\`. PRs will automatically target that branch.`,
+    `- If \`git push\` fails with "non-fast-forward" or similar, run \`git pull --rebase origin ${context.githubBranch}\` and retry. If that also fails, use \`git push --force-with-lease origin ${context.githubBranch}\`.`,
+    `- If you encounter merge conflicts during rebase, resolve them in place \u2014 do NOT abandon the branch.`
   ];
   if (setupLog.length > 0) {
     parts.push(
@@ -674,7 +726,7 @@ function buildCommonTools(connection, config) {
           );
         }
       },
-      { annotations: { readOnly: true } }
+      { annotations: { readOnlyHint: true } }
     ),
     tool(
       "post_to_chat",
@@ -708,7 +760,7 @@ function buildCommonTools(connection, config) {
           return textResult(`Task ID: ${config.taskId} - could not fetch updated plan.`);
         }
       },
-      { annotations: { readOnly: true } }
+      { annotations: { readOnlyHint: true } }
     )
   ];
 }
@@ -729,6 +781,74 @@ function buildPmTools(connection) {
           return textResult("Failed to update task.");
         }
       }
+    ),
+    tool(
+      "create_subtask",
+      "Create a subtask under the current parent task. Use for breaking complex tasks into smaller pieces.",
+      {
+        title: z.string().describe("Subtask title"),
+        description: z.string().optional().describe("Brief description"),
+        plan: z.string().optional().describe("Implementation plan in markdown"),
+        ordinal: z.number().optional().describe("Step/order number (0-based)"),
+        storyPointValue: z.number().optional().describe("Story point value (1=Common, 2=Magic, 3=Rare, 5=Unique)")
+      },
+      async (params) => {
+        try {
+          const result = await connection.createSubtask(params);
+          return textResult(`Subtask created with ID: ${result.id}`);
+        } catch (error) {
+          return textResult(
+            `Failed to create subtask: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+    ),
+    tool(
+      "update_subtask",
+      "Update an existing subtask's fields",
+      {
+        subtaskId: z.string().describe("The subtask ID to update"),
+        title: z.string().optional(),
+        description: z.string().optional(),
+        plan: z.string().optional(),
+        ordinal: z.number().optional(),
+        storyPointValue: z.number().optional()
+      },
+      async ({ subtaskId, ...fields }) => {
+        try {
+          await Promise.resolve(connection.updateSubtask(subtaskId, fields));
+          return textResult("Subtask updated.");
+        } catch (error) {
+          return textResult(`Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+      }
+    ),
+    tool(
+      "delete_subtask",
+      "Delete a subtask",
+      { subtaskId: z.string().describe("The subtask ID to delete") },
+      async ({ subtaskId }) => {
+        try {
+          await Promise.resolve(connection.deleteSubtask(subtaskId));
+          return textResult("Subtask deleted.");
+        } catch (error) {
+          return textResult(`Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+      }
+    ),
+    tool(
+      "list_subtasks",
+      "List all subtasks under the current parent task",
+      {},
+      async () => {
+        try {
+          const subtasks = await connection.listSubtasks();
+          return textResult(JSON.stringify(subtasks, null, 2));
+        } catch {
+          return textResult("Failed to list subtasks.");
+        }
+      },
+      { annotations: { readOnlyHint: true } }
     )
   ];
 }
@@ -811,6 +931,7 @@ async function processAssistantEvent(event, host, turnToolCalls) {
 function handleResultEvent(event, host, context, startTime) {
   const resultEvent = event;
   let totalCostUsd = 0;
+  let deltaCost = 0;
   let retriable = false;
   if (resultEvent.subtype === "success") {
     totalCostUsd = "total_cost_usd" in resultEvent ? resultEvent.total_cost_usd : 0;
@@ -819,15 +940,18 @@ function handleResultEvent(event, host, context, startTime) {
     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);
+    const lastCost = context._lastReportedCostUsd ?? 0;
+    deltaCost = totalCostUsd - lastCost;
+    context._lastReportedCostUsd = totalCostUsd;
+    host.connection.sendEvent({ type: "completed", summary, costUsd: deltaCost, durationMs });
+    if (deltaCost > 0 && context.agentId) {
+      const estimatedDeltaTokens = Math.round(deltaCost * 1e5);
       host.connection.trackSpending({
         agentId: context.agentId,
-        inputTokens: Math.round(estimatedTotalTokens * 0.7),
-        outputTokens: Math.round(estimatedTotalTokens * 0.3),
-        totalTokens: estimatedTotalTokens,
-        totalCostUsd,
+        inputTokens: Math.round(estimatedDeltaTokens * 0.7),
+        outputTokens: Math.round(estimatedDeltaTokens * 0.3),
+        totalTokens: estimatedDeltaTokens,
+        totalCostUsd: deltaCost,
         onSubscription: host.config.mode === "pm" || !!process.env.CLAUDE_CODE_OAUTH_TOKEN
       });
     }
@@ -839,16 +963,16 @@ function handleResultEvent(event, host, context, startTime) {
     }
     host.connection.sendEvent({ type: "error", message: errorMsg });
   }
-  return { totalCostUsd, retriable };
+  return { totalCostUsd, deltaCost, 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) {
+  if (result.deltaCost > 0 && context.agentId) {
     await host.callbacks.onEvent({
       type: "completed",
       summary: "Task completed.",
-      costUsd: result.totalCostUsd,
+      costUsd: result.deltaCost,
       durationMs
     });
   } else {
@@ -884,6 +1008,9 @@ async function processEvents(events, context, host) {
           if (sessionId && !sessionIdStored) {
             sessionIdStored = true;
             host.connection.storeSessionId(sessionId);
+            if (sessionId !== context.claudeSessionId) {
+              context._lastReportedCostUsd = 0;
+            }
           }
           await host.callbacks.onEvent({
             type: "thinking",
@@ -940,8 +1067,8 @@ function buildCanUseTool(host) {
       input: JSON.stringify(input)
     });
     const answerPromise = host.connection.askUserQuestion(requestId, questions);
-    const timeoutPromise = new Promise((resolve) => {
-      setTimeout(() => resolve(null), QUESTION_TIMEOUT_MS);
+    const timeoutPromise = new Promise((resolve2) => {
+      setTimeout(() => resolve2(null), QUESTION_TIMEOUT_MS);
     });
     const answers = await Promise.race([answerPromise, timeoutPromise]);
     host.connection.emitStatus("running");
@@ -1019,23 +1146,27 @@ ${followUpContent}` : followUpContent;
 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 }
-    });
+    const agentQuery = attempt === 0 ? initialQuery : (() => {
+      context._lastReportedCostUsd = 0;
+      return 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) {
+        context.claudeSessionId = null;
+        context._lastReportedCostUsd = 0;
         host.connection.storeSessionId("");
-        const freshCtx = { ...context, claudeSessionId: null };
         const freshQuery = query({
-          prompt: host.createInputStream(buildInitialPrompt(host.config.mode, freshCtx)),
+          prompt: host.createInputStream(buildInitialPrompt(host.config.mode, context)),
           options: { ...options, resume: void 0 }
         });
-        return runWithRetry(freshQuery, freshCtx, host, options);
+        return runWithRetry(freshQuery, context, host, options);
       }
       const isApiError = error instanceof Error && API_ERROR_PATTERN.test(error.message);
       if (!isApiError) throw error;
@@ -1057,13 +1188,13 @@ async function runWithRetry(initialQuery, context, host, options) {
     });
     host.connection.emitStatus("waiting_for_input");
     await host.callbacks.onStatusChange("waiting_for_input");
-    await new Promise((resolve) => {
-      const timer = setTimeout(resolve, delayMs);
+    await new Promise((resolve2) => {
+      const timer = setTimeout(resolve2, delayMs);
       const checkStopped = setInterval(() => {
         if (host.isStopped()) {
           clearTimeout(timer);
           clearInterval(checkStopped);
-          resolve();
+          resolve2();
         }
       }, 1e3);
       setTimeout(() => clearInterval(checkStopped), delayMs + 100);
@@ -1159,6 +1290,9 @@ var AgentRunner = class _AgentRunner {
       this.connection.disconnect();
       return;
     }
+    if (this.taskContext.claudeSessionId && this.taskContext._existingSpendingTotal !== null) {
+      this.taskContext._lastReportedCostUsd = this.taskContext._existingSpendingTotal;
+    }
     if (process.env.CODESPACES === "true" && this.taskContext.baseBranch) {
       const result = cleanDevcontainerFromGit(
         this.config.workspaceDir,
@@ -1327,25 +1461,25 @@ ${f.content}
       parent_tool_use_id: null
     };
     if (this.inputResolver) {
-      const resolve = this.inputResolver;
+      const resolve2 = this.inputResolver;
       this.inputResolver = null;
-      resolve(msg);
+      resolve2(msg);
     } else {
       this.pendingMessages.push(msg);
     }
   }
   waitForMessage() {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const checkStopped = setInterval(() => {
         if (this.stopped) {
           clearInterval(checkStopped);
           this.inputResolver = null;
-          resolve(null);
+          resolve2(null);
         }
       }, 1e3);
       this.inputResolver = (msg) => {
         clearInterval(checkStopped);
-        resolve(msg);
+        resolve2(msg);
       };
     });
   }
@@ -1381,64 +1515,78 @@ ${f.content}
       yield msg;
     }
   }
+  getPlanDirs() {
+    return [
+      join3(homedir(), ".claude", "plans"),
+      join3(this.config.workspaceDir, ".claude", "plans")
+    ];
+  }
   /**
    * 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();
     this.lockedPlanFile = null;
-    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;
+    for (const plansDir of this.getPlanDirs()) {
+      try {
+        for (const file of readdirSync(plansDir).filter((f) => f.endsWith(".md"))) {
+          try {
+            const fullPath = join3(plansDir, file);
+            const stat = statSync(fullPath);
+            this.planFileSnapshot.set(fullPath, stat.mtimeMs);
+          } catch {
+            continue;
+          }
         }
+      } catch {
       }
-    } catch {
     }
   }
   syncPlanFile() {
-    const plansDir = join3(homedir(), ".claude", "plans");
     if (this.lockedPlanFile) {
-      const fullPath = join3(plansDir, this.lockedPlanFile);
       try {
-        const content = readFileSync(fullPath, "utf-8").trim();
+        const content = readFileSync(this.lockedPlanFile, "utf-8").trim();
         if (content) {
           this.connection.updateTaskFields({ plan: content });
+          const fileName = this.lockedPlanFile.split("/").pop();
+          this.connection.postChatMessage(`Synced local plan file (${fileName}) to the task plan.`);
         }
       } catch {
       }
       return;
     }
-    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);
+    for (const plansDir of this.getPlanDirs()) {
+      let files;
       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 };
-        }
+        files = readdirSync(plansDir).filter((f) => f.endsWith(".md"));
       } catch {
         continue;
       }
+      for (const file of files) {
+        const fullPath = join3(plansDir, file);
+        try {
+          const stat = statSync(fullPath);
+          const prevMtime = this.planFileSnapshot.get(fullPath);
+          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) {
-      this.lockedPlanFile = newest.path.split("/").pop();
+      this.lockedPlanFile = newest.path;
       const content = readFileSync(newest.path, "utf-8").trim();
       if (content) {
         this.connection.updateTaskFields({ plan: content });
+        const fileName = newest.path.split("/").pop();
+        this.connection.postChatMessage(
+          `Detected local plan file (${fileName}) and synced it to the task plan.`
+        );
       }
     }
   }
@@ -1463,6 +1611,260 @@ ${f.content}
   }
 };
 
+// src/project-connection.ts
+import { io as io2 } from "socket.io-client";
+var ProjectConnection = class {
+  socket = null;
+  config;
+  taskAssignmentCallback = null;
+  stopTaskCallback = null;
+  constructor(config) {
+    this.config = config;
+  }
+  connect() {
+    return new Promise((resolve2, reject) => {
+      let settled = false;
+      let attempts = 0;
+      const maxInitialAttempts = 30;
+      this.socket = io2(this.config.apiUrl, {
+        auth: { projectToken: this.config.projectToken },
+        transports: ["websocket"],
+        reconnection: true,
+        reconnectionAttempts: Infinity,
+        reconnectionDelay: 2e3,
+        reconnectionDelayMax: 3e4,
+        randomizationFactor: 0.3,
+        extraHeaders: {
+          "ngrok-skip-browser-warning": "true"
+        }
+      });
+      this.socket.on("projectRunner:assignTask", (data) => {
+        if (this.taskAssignmentCallback) {
+          this.taskAssignmentCallback(data);
+        }
+      });
+      this.socket.on("projectRunner:stopTask", (data) => {
+        if (this.stopTaskCallback) {
+          this.stopTaskCallback(data);
+        }
+      });
+      this.socket.on("connect", () => {
+        if (!settled) {
+          settled = true;
+          resolve2();
+        }
+      });
+      this.socket.io.on("reconnect_attempt", () => {
+        attempts++;
+        if (!settled && attempts >= maxInitialAttempts) {
+          settled = true;
+          reject(new Error(`Failed to connect after ${maxInitialAttempts} attempts`));
+        }
+      });
+    });
+  }
+  onTaskAssignment(callback) {
+    this.taskAssignmentCallback = callback;
+  }
+  onStopTask(callback) {
+    this.stopTaskCallback = callback;
+  }
+  sendHeartbeat() {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:heartbeat", {});
+  }
+  emitTaskStarted(taskId) {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:taskStarted", { taskId });
+  }
+  emitTaskStopped(taskId, reason) {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:taskStopped", { taskId, reason });
+  }
+  disconnect() {
+    this.socket?.disconnect();
+    this.socket = null;
+  }
+};
+
+// src/project-runner.ts
+import { fork } from "child_process";
+import { execSync as execSync4 } from "child_process";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var HEARTBEAT_INTERVAL_MS2 = 3e4;
+var MAX_CONCURRENT = 3;
+var STOP_TIMEOUT_MS = 3e4;
+var ProjectRunner = class {
+  connection;
+  projectDir;
+  activeAgents = /* @__PURE__ */ new Map();
+  heartbeatTimer = null;
+  stopping = false;
+  constructor(config) {
+    this.projectDir = config.projectDir;
+    this.connection = new ProjectConnection({
+      apiUrl: config.conveyorApiUrl,
+      projectToken: config.projectToken,
+      projectId: config.projectId
+    });
+  }
+  async start() {
+    await this.connection.connect();
+    this.connection.onTaskAssignment((assignment) => {
+      void this.handleAssignment(assignment);
+    });
+    this.connection.onStopTask((data) => {
+      this.handleStopTask(data.taskId);
+    });
+    this.heartbeatTimer = setInterval(() => {
+      this.connection.sendHeartbeat();
+    }, HEARTBEAT_INTERVAL_MS2);
+    console.log("[project-runner] Connected, waiting for task assignments...");
+    await new Promise((resolve2) => {
+      process.on("SIGTERM", () => {
+        void this.stop().then(resolve2);
+      });
+      process.on("SIGINT", () => {
+        void this.stop().then(resolve2);
+      });
+    });
+  }
+  async handleAssignment(assignment) {
+    const { taskId, taskToken, apiUrl, mode, branch, devBranch } = assignment;
+    const shortId = taskId.slice(0, 8);
+    if (this.activeAgents.has(taskId)) {
+      console.log(`[project-runner] Task ${shortId} already running, skipping`);
+      return;
+    }
+    if (this.activeAgents.size >= MAX_CONCURRENT) {
+      console.log(
+        `[project-runner] Max concurrent agents (${MAX_CONCURRENT}) reached, rejecting task ${shortId}`
+      );
+      this.connection.emitTaskStopped(taskId, "max_concurrent_reached");
+      return;
+    }
+    try {
+      try {
+        execSync4("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
+      } catch {
+        console.log(`[task:${shortId}] Warning: git fetch failed`);
+      }
+      const worktreePath = ensureWorktree(this.projectDir, taskId, devBranch);
+      if (branch && branch !== devBranch) {
+        try {
+          execSync4(`git checkout ${branch}`, { cwd: worktreePath, stdio: "ignore" });
+        } catch {
+          try {
+            execSync4(`git checkout -b ${branch}`, { cwd: worktreePath, stdio: "ignore" });
+          } catch {
+            console.log(`[task:${shortId}] Warning: could not checkout branch ${branch}`);
+          }
+        }
+      }
+      const cliPath = path.resolve(__dirname, "cli.js");
+      const child = fork(cliPath, [], {
+        env: {
+          ...process.env,
+          CONVEYOR_API_URL: apiUrl,
+          CONVEYOR_TASK_TOKEN: taskToken,
+          CONVEYOR_TASK_ID: taskId,
+          CONVEYOR_MODE: mode,
+          CONVEYOR_WORKSPACE: worktreePath,
+          CONVEYOR_USE_WORKTREE: "false"
+        },
+        cwd: worktreePath,
+        stdio: ["pipe", "pipe", "pipe", "ipc"]
+      });
+      child.stdout?.on("data", (data) => {
+        const lines = data.toString().trimEnd().split("\n");
+        for (const line of lines) {
+          console.log(`[task:${shortId}] ${line}`);
+        }
+      });
+      child.stderr?.on("data", (data) => {
+        const lines = data.toString().trimEnd().split("\n");
+        for (const line of lines) {
+          console.error(`[task:${shortId}] ${line}`);
+        }
+      });
+      this.activeAgents.set(taskId, { process: child, worktreePath, mode });
+      this.connection.emitTaskStarted(taskId);
+      console.log(`[project-runner] Started task ${shortId} in ${mode} mode at ${worktreePath}`);
+      child.on("exit", (code) => {
+        this.activeAgents.delete(taskId);
+        const reason = code === 0 ? "completed" : `exited with code ${code}`;
+        this.connection.emitTaskStopped(taskId, reason);
+        console.log(`[project-runner] Task ${shortId} ${reason}`);
+        if (code === 0) {
+          try {
+            removeWorktree(this.projectDir, taskId);
+          } catch {
+          }
+        }
+      });
+    } catch (error) {
+      console.error(
+        `[project-runner] Failed to start task ${shortId}:`,
+        error instanceof Error ? error.message : error
+      );
+      this.connection.emitTaskStopped(
+        taskId,
+        `start_failed: ${error instanceof Error ? error.message : "Unknown"}`
+      );
+    }
+  }
+  handleStopTask(taskId) {
+    const agent = this.activeAgents.get(taskId);
+    if (!agent) return;
+    const shortId = taskId.slice(0, 8);
+    console.log(`[project-runner] Stopping task ${shortId}`);
+    agent.process.kill("SIGTERM");
+    const timer = setTimeout(() => {
+      if (this.activeAgents.has(taskId)) {
+        agent.process.kill("SIGKILL");
+      }
+    }, STOP_TIMEOUT_MS);
+    agent.process.on("exit", () => {
+      clearTimeout(timer);
+      try {
+        removeWorktree(this.projectDir, taskId);
+      } catch {
+      }
+    });
+  }
+  async stop() {
+    if (this.stopping) return;
+    this.stopping = true;
+    console.log("[project-runner] Shutting down...");
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    const stopPromises = [...this.activeAgents.keys()].map(
+      (taskId) => new Promise((resolve2) => {
+        const agent = this.activeAgents.get(taskId);
+        if (!agent) {
+          resolve2();
+          return;
+        }
+        agent.process.on("exit", () => {
+          resolve2();
+        });
+        this.handleStopTask(taskId);
+      })
+    );
+    await Promise.race([
+      Promise.all(stopPromises),
+      new Promise((resolve2) => setTimeout(resolve2, 6e4))
+    ]);
+    this.connection.disconnect();
+    console.log("[project-runner] Shutdown complete");
+  }
+};
+
 export {
   ConveyorConnection,
   loadConveyorConfig,
@@ -1470,6 +1872,8 @@ export {
   runStartCommand,
   ensureWorktree,
   removeWorktree,
-  AgentRunner
+  AgentRunner,
+  ProjectConnection,
+  ProjectRunner
 };
-//# sourceMappingURL=chunk-WD6A5AYJ.js.map
+//# sourceMappingURL=chunk-KFCGF2SX.js.map