@rallycry/conveyor-agent 5.9.4 → 5.10.0

package/dist/{chunk-N3TSLBSH.js → chunk-MRTSBPY7.js}

@@ -454,9 +454,15 @@ var ProjectConnection = class {
   shutdownCallback = null;
   chatMessageCallback = null;
   earlyChatMessages = [];
+  auditRequestCallback = null;
+  // Branch switching callbacks
+  onSwitchBranch = null;
+  onSyncEnvironment = null;
+  onGetEnvStatus = null;
   constructor(config) {
     this.config = config;
   }
+  // oxlint-disable-next-line max-lines-per-function -- socket event registration requires co-located handlers
   connect() {
     return new Promise((resolve2, reject) => {
       let settled = false;
@@ -496,6 +502,30 @@ var ProjectConnection = class {
           this.earlyChatMessages.push(msg);
         }
       });
+      this.socket.on("projectRunner:auditTags", (data) => {
+        if (this.auditRequestCallback) {
+          this.auditRequestCallback(data);
+        }
+      });
+      this.socket.on(
+        "projectRunner:switchBranch",
+        (data, cb) => {
+          if (this.onSwitchBranch) this.onSwitchBranch(data, cb);
+          else cb({ ok: false, error: "switchBranch handler not registered" });
+        }
+      );
+      this.socket.on("projectRunner:syncEnvironment", (cb) => {
+        if (this.onSyncEnvironment) this.onSyncEnvironment(cb);
+        else cb({ ok: false, error: "syncEnvironment handler not registered" });
+      });
+      this.socket.on("projectRunner:getEnvStatus", (cb) => {
+        if (this.onGetEnvStatus) this.onGetEnvStatus(cb);
+        else cb({ ok: false, data: void 0 });
+      });
+      this.socket.on(
+        "projectRunner:runAuthTokenCommand",
+        (data, cb) => this.handleRunAuthTokenCommand(data.userEmail, cb)
+      );
       this.socket.on("connect", () => {
         if (!settled) {
           settled = true;
@@ -527,6 +557,13 @@ var ProjectConnection = class {
     }
     this.earlyChatMessages = [];
   }
+  onAuditRequest(callback) {
+    this.auditRequestCallback = callback;
+  }
+  emitAuditResult(data) {
+    if (!this.socket) return;
+    this.socket.emit("conveyor:tagAuditResult", data);
+  }
   sendHeartbeat() {
     if (!this.socket) return;
     this.socket.emit("projectRunner:heartbeat", {});
@@ -588,6 +625,46 @@ var ProjectConnection = class {
       );
     });
   }
+  emitNewCommitsDetected(data) {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:newCommitsDetected", data);
+  }
+  emitEnvironmentReady(data) {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:environmentReady", data);
+  }
+  emitEnvSwitchProgress(data) {
+    if (!this.socket) return;
+    this.socket.emit("projectRunner:envSwitchProgress", data);
+  }
+  handleRunAuthTokenCommand(userEmail, cb) {
+    try {
+      if (process.env.CODESPACES !== "true") {
+        cb({ ok: false, error: "Auth token command only available in codespace environments" });
+        return;
+      }
+      const authCmd = process.env.CONVEYOR_AUTH_TOKEN_COMMAND;
+      if (!authCmd) {
+        cb({ ok: false, error: "CONVEYOR_AUTH_TOKEN_COMMAND not configured" });
+        return;
+      }
+      const cwd = this.config.projectDir ?? process.cwd();
+      const token = runAuthTokenCommand(authCmd, userEmail, cwd);
+      if (!token) {
+        cb({
+          ok: false,
+          error: `Auth token command returned empty output. Command: ${authCmd}`
+        });
+        return;
+      }
+      cb({ ok: true, token });
+    } catch (error) {
+      cb({
+        ok: false,
+        error: error instanceof Error ? error.message : "Auth token command failed"
+      });
+    }
+  }
   disconnect() {
     this.socket?.disconnect();
     this.socket = null;
@@ -1178,6 +1255,184 @@ After addressing the feedback, resume your autonomous loop: call list_subtasks a
   return parts;
 }
 
+// src/execution/tag-context-resolver.ts
+import { readFile as readFile2, readdir } from "fs/promises";
+var TYPE_PRIORITY = { rule: 0, file: 1, folder: 2, doc: 3 };
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".svg",
+  ".bmp",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".wasm"
+]);
+function isBinaryPath(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+function getContextBudgetChars(_model, betas) {
+  const contextWindow = betas?.some((b) => b.includes("context-1m")) ? 1e6 : 2e5;
+  return contextWindow * 0.25 * 4;
+}
+async function readFileContent(filePath, maxChars) {
+  try {
+    if (isBinaryPath(filePath)) return null;
+    const content = await readFile2(filePath, "utf-8");
+    if (content.length > maxChars) {
+      const omitted = content.length - maxChars;
+      return content.slice(0, maxChars) + `
+[... truncated, ${omitted} chars omitted]`;
+    }
+    return content;
+  } catch {
+    return null;
+  }
+}
+async function readFolderListing(folderPath) {
+  try {
+    const entries = await readdir(folderPath);
+    return `Files: ${entries.join(", ")}`;
+  } catch {
+    return null;
+  }
+}
+async function resolveEntry(entry, budget) {
+  const result = {
+    type: entry.type,
+    path: entry.path,
+    label: entry.label,
+    content: null,
+    charCount: 0
+  };
+  if (budget.remaining <= 0) return result;
+  if (entry.type === "doc") {
+    return result;
+  }
+  if (entry.type === "folder") {
+    const listing = await readFolderListing(entry.path);
+    if (listing) {
+      result.content = listing;
+      result.charCount = listing.length;
+      budget.remaining -= listing.length;
+    }
+    return result;
+  }
+  const maxChars = Math.floor(budget.remaining * 0.5) || budget.remaining;
+  const content = await readFileContent(entry.path, maxChars);
+  if (content) {
+    result.content = content;
+    result.charCount = content.length;
+    budget.remaining -= content.length;
+  }
+  return result;
+}
+function formatEntry(entry) {
+  const label = entry.label ? ` (${entry.label})` : "";
+  const header = `#### ${entry.path}${label} (${entry.type})`;
+  if (entry.content === null) {
+    return `> ${entry.type}: ${entry.path}${label}`;
+  }
+  if (entry.type === "folder") {
+    return `${header}
+${entry.content}`;
+  }
+  return `${header}
+\`\`\`
+${entry.content}
+\`\`\``;
+}
+function formatResolvedTags(resolved) {
+  const parts = [`
+## Tag Context`];
+  for (const tag of resolved) {
+    if (tag.entries.length === 0) continue;
+    const desc = tag.description ? ` \u2014 ${tag.description}` : "";
+    parts.push(`
+### Tag: "${tag.tagName}"${desc}`);
+    const contentEntries = tag.entries.filter((e) => e.content !== null);
+    const pointerEntries = tag.entries.filter((e) => e.content === null);
+    for (const entry of contentEntries) {
+      parts.push(`
+${formatEntry(entry)}`);
+    }
+    if (pointerEntries.length > 0) {
+      parts.push(``);
+      parts.push(`> Budget limit reached. Remaining linked files (read manually if needed):`);
+      for (const entry of pointerEntries) {
+        parts.push(formatEntry(entry));
+      }
+    }
+  }
+  return parts.join("\n");
+}
+async function resolveTagContext(projectTags, taskTagIds, model, betas) {
+  if (!projectTags?.length || !taskTagIds.length) {
+    return { injectedSection: "", stats: { injected: 0, skipped: 0 } };
+  }
+  const taskTagIdSet = new Set(taskTagIds);
+  const assignedTags = projectTags.filter((t) => taskTagIdSet.has(t.id));
+  if (assignedTags.length === 0) {
+    return { injectedSection: "", stats: { injected: 0, skipped: 0 } };
+  }
+  const allEntries = [];
+  for (let i = 0; i < assignedTags.length; i++) {
+    const tag = assignedTags[i];
+    if (!tag.contextPaths?.length) continue;
+    const sorted = [...tag.contextPaths].sort(
+      (a, b) => (TYPE_PRIORITY[a.type] ?? 99) - (TYPE_PRIORITY[b.type] ?? 99)
+    );
+    for (const entry of sorted) {
+      allEntries.push({ tagIndex: i, entry });
+    }
+  }
+  if (allEntries.length === 0) {
+    return { injectedSection: "", stats: { injected: 0, skipped: 0 } };
+  }
+  const budgetChars = getContextBudgetChars(model, betas);
+  const budget = { remaining: budgetChars };
+  let injected = 0;
+  let skipped = 0;
+  const resolved = assignedTags.map((t) => ({
+    tagName: t.name,
+    description: t.description,
+    entries: []
+  }));
+  for (const { tagIndex, entry } of allEntries) {
+    const result = await resolveEntry(entry, budget);
+    resolved[tagIndex].entries.push(result);
+    if (result.content === null) {
+      skipped++;
+    } else {
+      injected++;
+    }
+  }
+  return {
+    injectedSection: formatResolvedTags(resolved),
+    stats: { injected, skipped }
+  };
+}
+
 // src/execution/mode-prompt.ts
 function buildPropertyInstructions(context) {
   const parts = [];
@@ -1206,6 +1461,12 @@ function buildPropertyInstructions(context) {
     for (const tag of context.projectTags) {
       const desc = tag.description ? ` \u2014 ${tag.description}` : "";
       parts.push(`- ID: "${tag.id}", Name: "${tag.name}"${desc}`);
+      if (tag.contextPaths?.length) {
+        for (const link of tag.contextPaths) {
+          const label = link.label ? ` (${link.label})` : "";
+          parts.push(`    \u2192 ${link.type}: ${link.path}${label}`);
+        }
+      }
     }
   }
   return parts;
@@ -1351,6 +1612,14 @@ Project Agents:`);
       parts.push(formatProjectAgentLine(pa));
     }
   }
+  if (context.projectObjectives && context.projectObjectives.length > 0) {
+    parts.push(`
+Project Objectives:`);
+    for (const obj of context.projectObjectives) {
+      const dates = `${obj.startDate.split("T")[0]} to ${obj.endDate.split("T")[0]}`;
+      parts.push(`- **${obj.name}** (${dates})${obj.description ? ": " + obj.description : ""}`);
+    }
+  }
   return parts;
 }
 function buildActivePreamble(context, workspaceDir) {
@@ -1588,7 +1857,17 @@ function formatChatHistory(chatHistory) {
   }
   return parts;
 }
-function buildTaskBody(context) {
+async function resolveTaskTagContext(context) {
+  if (!context.projectTags?.length || !context.taskTagIds?.length) return null;
+  const { injectedSection } = await resolveTagContext(
+    context.projectTags,
+    context.taskTagIds,
+    context.model,
+    context.agentSettings?.betas
+  );
+  return injectedSection || null;
+}
+async function buildTaskBody(context) {
   const parts = [];
   parts.push(`# Task: ${context.title}`);
   if (context.description) {
@@ -1616,6 +1895,8 @@ ${context.plan}`);
       parts.push(`- [${icon}] \`${ref.path}\``);
     }
   }
+  const tagSection = await resolveTaskTagContext(context);
+  if (tagSection) parts.push(tagSection);
   if (context.chatHistory.length > 0) {
     parts.push(...formatChatHistory(context.chatHistory));
   }
@@ -1767,7 +2048,7 @@ function buildInstructions(mode, context, scenario, agentMode) {
   parts.push(...buildFeedbackInstructions(context, isPm));
   return parts;
 }
-function buildInitialPrompt(mode, context, isAuto, agentMode) {
+async function buildInitialPrompt(mode, context, isAuto, agentMode) {
   const isPackRunner = mode === "pm" && !!isAuto && !!context.isParentTask;
   if (!isPackRunner) {
     const sessionRelaunch = buildRelaunchWithSession(mode, context, agentMode);
@@ -1775,7 +2056,7 @@ function buildInitialPrompt(mode, context, isAuto, agentMode) {
   }
   const isPm = mode === "pm";
   const scenario = detectRelaunchScenario(context, isPm);
-  const body = buildTaskBody(context);
+  const body = await buildTaskBody(context);
   const instructions = isPackRunner ? buildPackRunnerInstructions(context, scenario) : buildInstructions(mode, context, scenario, agentMode);
   return [...body, ...instructions].join("\n");
 }
@@ -2684,13 +2965,13 @@ function buildMultimodalPrompt(textPrompt, context, skipImages = false) {
   }
   return blocks;
 }
-function buildFollowUpPrompt(host, context, followUpContent) {
+async function buildFollowUpPrompt(host, context, followUpContent) {
   const isPmMode = host.config.mode === "pm";
   const followUpText = typeof followUpContent === "string" ? followUpContent : followUpContent.filter((b) => b.type === "text").map((b) => b.text).join("\n");
   const followUpImages = typeof followUpContent === "string" ? [] : followUpContent.filter(
     (b) => b.type === "image"
   );
-  const textPrompt = isPmMode ? `${buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode)}
+  const textPrompt = isPmMode ? `${await buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode)}
 
 ---
 
@@ -2719,7 +3000,7 @@ async function runSdkQuery(host, context, followUpContent) {
   const options = buildQueryOptions(host, context);
   const resume = context.claudeSessionId ?? void 0;
   if (followUpContent) {
-    const prompt = buildFollowUpPrompt(host, context, followUpContent);
+    const prompt = await buildFollowUpPrompt(host, context, followUpContent);
     const agentQuery = query({
       prompt: typeof prompt === "string" ? prompt : host.createInputStream(prompt),
       options: { ...options, resume }
@@ -2733,7 +3014,12 @@ async function runSdkQuery(host, context, followUpContent) {
   } else if (isDiscoveryLike) {
     return;
   } else {
-    const initialPrompt = buildInitialPrompt(host.config.mode, context, host.config.isAuto, mode);
+    const initialPrompt = await buildInitialPrompt(
+      host.config.mode,
+      context,
+      host.config.isAuto,
+      mode
+    );
     const prompt = buildMultimodalPrompt(initialPrompt, context);
     const agentQuery = query({
       prompt: host.createInputStream(prompt),
@@ -2750,14 +3036,14 @@ async function runSdkQuery(host, context, followUpContent) {
     host.syncPlanFile();
   }
 }
-function buildRetryQuery(host, context, options, lastErrorWasImage) {
+async function buildRetryQuery(host, context, options, lastErrorWasImage) {
   if (lastErrorWasImage) {
     host.connection.postChatMessage(
       "An attached image could not be processed. Retrying without images..."
     );
   }
   const retryPrompt = buildMultimodalPrompt(
-    buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode),
+    await buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode),
     context,
     lastErrorWasImage
   );
@@ -2766,11 +3052,11 @@ function buildRetryQuery(host, context, options, lastErrorWasImage) {
     options: { ...options, resume: void 0 }
   });
 }
-function handleStaleSession(context, host, options) {
+async function handleStaleSession(context, host, options) {
   context.claudeSessionId = null;
   host.connection.storeSessionId("");
   const freshPrompt = buildMultimodalPrompt(
-    buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode),
+    await buildInitialPrompt(host.config.mode, context, host.config.isAuto, host.agentMode),
     context
   );
   const freshQuery = query({
@@ -2836,7 +3122,7 @@ async function runWithRetry(initialQuery, context, host, options) {
   let lastErrorWasImage = false;
   for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {
     if (host.isStopped()) return;
-    const agentQuery = attempt === 0 ? initialQuery : buildRetryQuery(host, context, options, lastErrorWasImage);
+    const agentQuery = attempt === 0 ? initialQuery : await buildRetryQuery(host, context, options, lastErrorWasImage);
     try {
       const { retriable, resultSummary, modeRestart, rateLimitResetsAt, staleSession } = await processEvents(agentQuery, context, host);
       if (modeRestart || host.isStopped()) return;
@@ -3678,13 +3964,118 @@ var AgentRunner = class {
 
 // src/runner/project-runner.ts
 import { fork } from "child_process";
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 import * as path from "path";
 import { fileURLToPath } from "url";
 
+// src/runner/commit-watcher.ts
+import { execSync as execSync5 } from "child_process";
+var logger3 = createServiceLogger("CommitWatcher");
+var CommitWatcher = class {
+  constructor(config, callbacks) {
+    this.config = config;
+    this.callbacks = callbacks;
+  }
+  interval = null;
+  lastKnownRemoteSha = null;
+  branch = null;
+  debounceTimer = null;
+  isSyncing = false;
+  start(branch) {
+    this.stop();
+    this.branch = branch;
+    this.lastKnownRemoteSha = this.getLocalHeadSha();
+    this.interval = setInterval(() => void this.poll(), this.config.pollIntervalMs);
+    logger3.info("Commit watcher started", {
+      branch,
+      baseSha: this.lastKnownRemoteSha?.slice(0, 8)
+    });
+  }
+  stop() {
+    if (this.interval) clearInterval(this.interval);
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.interval = null;
+    this.debounceTimer = null;
+    this.branch = null;
+    this.lastKnownRemoteSha = null;
+    this.isSyncing = false;
+  }
+  getLocalHeadSha() {
+    return execSync5("git rev-parse HEAD", {
+      cwd: this.config.projectDir,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+  }
+  poll() {
+    if (!this.branch || this.isSyncing) return;
+    try {
+      execSync5(`git fetch origin ${this.branch} --quiet`, {
+        cwd: this.config.projectDir,
+        stdio: "ignore",
+        timeout: 3e4
+      });
+      const remoteSha = execSync5(`git rev-parse origin/${this.branch}`, {
+        cwd: this.config.projectDir,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString().trim();
+      if (remoteSha !== this.lastKnownRemoteSha) {
+        if (this.debounceTimer) clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(
+          () => void this.handleNewCommits(remoteSha),
+          this.config.debounceMs
+        );
+      }
+    } catch {
+    }
+  }
+  async handleNewCommits(remoteSha) {
+    if (!this.branch) return;
+    const previousSha = this.lastKnownRemoteSha ?? "HEAD";
+    let commitCount = 1;
+    let latestMessage = "";
+    let latestAuthor = "";
+    try {
+      const countOutput = execSync5(`git rev-list --count ${previousSha}..origin/${this.branch}`, {
+        cwd: this.config.projectDir,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString().trim();
+      commitCount = parseInt(countOutput, 10) || 1;
+      const logOutput = execSync5(`git log -1 --format="%s|||%an" origin/${this.branch}`, {
+        cwd: this.config.projectDir,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString().trim();
+      const parts = logOutput.split("|||");
+      latestMessage = parts[0] ?? "";
+      latestAuthor = parts[1] ?? "";
+    } catch {
+    }
+    this.lastKnownRemoteSha = remoteSha;
+    this.isSyncing = true;
+    logger3.info("New commits detected", {
+      branch: this.branch,
+      commitCount,
+      sha: remoteSha.slice(0, 8)
+    });
+    try {
+      await this.callbacks.onNewCommits({
+        branch: this.branch,
+        previousSha,
+        newCommitSha: remoteSha,
+        commitCount,
+        latestMessage,
+        latestAuthor
+      });
+    } catch (err) {
+      logger3.error("Error handling new commits", errorMeta(err));
+    } finally {
+      this.isSyncing = false;
+    }
+  }
+};
+
 // src/runner/project-chat-handler.ts
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
-var logger3 = createServiceLogger("ProjectChat");
+var logger4 = createServiceLogger("ProjectChat");
 var FALLBACK_MODEL = "claude-sonnet-4-20250514";
 function buildSystemPrompt2(projectDir, agentCtx) {
   const parts = [];
@@ -3737,7 +4128,7 @@ function processContentBlock(block, responseParts, turnToolCalls) {
       input: inputStr.slice(0, 1e4),
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
-    logger3.debug("Tool use", { tool: block.name });
+    logger4.debug("Tool use", { tool: block.name });
   }
 }
 async function fetchContext(connection) {
@@ -3745,13 +4136,13 @@ async function fetchContext(connection) {
   try {
     agentCtx = await connection.fetchAgentContext();
   } catch {
-    logger3.warn("Could not fetch agent context, using defaults");
+    logger4.warn("Could not fetch agent context, using defaults");
   }
   let chatHistory = [];
   try {
     chatHistory = await connection.fetchChatHistory(30);
   } catch {
-    logger3.warn("Could not fetch chat history, proceeding without it");
+    logger4.warn("Could not fetch chat history, proceeding without it");
   }
   return { agentCtx, chatHistory };
 }
@@ -3804,6 +4195,7 @@ async function runChatQuery(message, connection, projectDir) {
   const { agentCtx, chatHistory } = await fetchContext(connection);
   const options = buildChatQueryOptions(agentCtx, projectDir);
   const prompt = buildPrompt(message, chatHistory);
+  connection.emitAgentStatus("running");
   const events = query2({ prompt, options });
   const responseParts = [];
   const turnToolCalls = [];
@@ -3821,11 +4213,12 @@ async function runChatQuery(message, connection, projectDir) {
   }
 }
 async function handleProjectChatMessage(message, connection, projectDir) {
-  connection.emitAgentStatus("busy");
+  connection.emitAgentStatus("fetching_context");
   try {
     await runChatQuery(message, connection, projectDir);
   } catch (error) {
-    logger3.error("Failed to handle message", errorMeta(error));
+    logger4.error("Failed to handle message", errorMeta(error));
+    connection.emitAgentStatus("error");
     try {
       await connection.emitChatMessage(
         "I encountered an error processing your message. Please try again."
@@ -3837,13 +4230,360 @@ async function handleProjectChatMessage(message, connection, projectDir) {
   }
 }
 
+// src/runner/project-audit-handler.ts
+import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
+
+// src/tools/audit-tools.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { tool as tool4, createSdkMcpServer as createSdkMcpServer2 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z4 } from "zod";
+function mapCreateTag(input) {
+  return {
+    type: "create_tag",
+    tagName: input.name,
+    suggestion: `Create new tag "${input.name}"${input.description ? `: ${input.description}` : ""}`,
+    reasoning: input.reasoning,
+    payload: { name: input.name, color: input.color ?? "#6B7280", description: input.description }
+  };
+}
+function mapUpdateDescription(input) {
+  return {
+    type: "update_description",
+    tagId: input.tagId,
+    tagName: input.tagName,
+    suggestion: `Update description for "${input.tagName}"`,
+    reasoning: input.reasoning,
+    payload: { description: input.description }
+  };
+}
+function mapContextLink(input) {
+  return {
+    type: "add_context_link",
+    tagId: input.tagId,
+    tagName: input.tagName,
+    suggestion: `Link ${input.linkType}:${input.path} to "${input.tagName}"`,
+    reasoning: input.reasoning,
+    payload: { contextLink: { type: input.linkType, path: input.path, label: input.label } }
+  };
+}
+function mapDocGap(input) {
+  return {
+    type: "documentation_gap",
+    tagId: input.tagId,
+    tagName: input.tagName,
+    suggestion: `Documentation gap: ${input.filePath} (${input.readCount} reads)`,
+    reasoning: input.reasoning,
+    payload: {
+      filePath: input.filePath,
+      readCount: input.readCount,
+      suggestedAction: input.suggestedAction
+    }
+  };
+}
+function mapMergeTags(input) {
+  return {
+    type: "merge_tags",
+    tagId: input.tagId,
+    tagName: input.tagName,
+    suggestion: `Merge "${input.tagName}" into "${input.mergeIntoTagName}"`,
+    reasoning: input.reasoning,
+    payload: { mergeIntoTagId: input.mergeIntoTagId }
+  };
+}
+function mapRenameTag(input) {
+  return {
+    type: "rename_tag",
+    tagId: input.tagId,
+    tagName: input.tagName,
+    suggestion: `Rename "${input.tagName}" to "${input.newName}"`,
+    reasoning: input.reasoning,
+    payload: { newName: input.newName }
+  };
+}
+var TOOL_MAPPERS = {
+  recommend_create_tag: mapCreateTag,
+  recommend_update_description: mapUpdateDescription,
+  recommend_context_link: mapContextLink,
+  flag_documentation_gap: mapDocGap,
+  recommend_merge_tags: mapMergeTags,
+  recommend_rename_tag: mapRenameTag
+};
+function collectRecommendation(toolName, input, collector) {
+  const mapper = TOOL_MAPPERS[toolName];
+  if (!mapper) return JSON.stringify({ error: `Unknown tool: ${toolName}` });
+  const rec = { id: randomUUID3(), ...mapper(input) };
+  collector.recommendations.push(rec);
+  return JSON.stringify({ success: true, recommendationId: rec.id });
+}
+function createAuditMcpServer(collector) {
+  const auditTools = [
+    tool4(
+      "recommend_create_tag",
+      "Recommend creating a new tag for an uncovered subsystem or area",
+      {
+        name: z4.string().describe("Proposed tag name (lowercase, hyphenated)"),
+        color: z4.string().optional().describe("Hex color code"),
+        description: z4.string().describe("What this tag covers"),
+        reasoning: z4.string().describe("Why this tag should be created")
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_create_tag",
+          args,
+          collector
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool4(
+      "recommend_update_description",
+      "Recommend updating a tag's description to better reflect its scope",
+      {
+        tagId: z4.string(),
+        tagName: z4.string(),
+        description: z4.string().describe("Proposed new description"),
+        reasoning: z4.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_update_description",
+          args,
+          collector
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool4(
+      "recommend_context_link",
+      "Recommend linking a doc, rule, file, or folder to a tag's contextPaths",
+      {
+        tagId: z4.string(),
+        tagName: z4.string(),
+        linkType: z4.enum(["rule", "doc", "file", "folder"]),
+        path: z4.string(),
+        label: z4.string().optional(),
+        reasoning: z4.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_context_link",
+          args,
+          collector
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool4(
+      "flag_documentation_gap",
+      "Flag a file that agents read heavily but has no tag documentation linked",
+      {
+        tagName: z4.string().describe("Tag whose agents read this file"),
+        tagId: z4.string().optional(),
+        filePath: z4.string(),
+        readCount: z4.number(),
+        suggestedAction: z4.string().describe("What doc or rule should be created"),
+        reasoning: z4.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "flag_documentation_gap",
+          args,
+          collector
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool4(
+      "recommend_merge_tags",
+      "Recommend merging one tag into another",
+      {
+        tagId: z4.string().describe("Tag ID to be merged (removed after merge)"),
+        tagName: z4.string().describe("Name of the tag to be merged"),
+        mergeIntoTagId: z4.string().describe("Tag ID to merge into (kept)"),
+        mergeIntoTagName: z4.string(),
+        reasoning: z4.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_merge_tags",
+          args,
+          collector
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool4(
+      "recommend_rename_tag",
+      "Recommend renaming a tag",
+      {
+        tagId: z4.string(),
+        tagName: z4.string().describe("Current tag name"),
+        newName: z4.string().describe("Proposed new name"),
+        reasoning: z4.string()
+      },
+      async (args) => {
+        const result = collectRecommendation(
+          "recommend_rename_tag",
+          args,
+          collector
+        );
+        return { content: [{ type: "text", text: result }] };
+      }
+    ),
+    tool4(
+      "complete_audit",
+      "Signal that the audit is complete with a summary of all findings",
+      { summary: z4.string().describe("Brief overview of all findings") },
+      async (args) => {
+        collector.complete = true;
+        collector.summary = args.summary ?? "Audit completed.";
+        return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+      }
+    )
+  ];
+  return createSdkMcpServer2({
+    name: "tag-audit",
+    tools: auditTools
+  });
+}
+
+// src/runner/project-audit-handler.ts
+var logger5 = createServiceLogger("ProjectAudit");
+var FALLBACK_MODEL2 = "claude-sonnet-4-20250514";
+function buildTagSection(tags) {
+  if (tags.length === 0) return "No tags configured yet.";
+  return tags.map((t) => {
+    const paths = t.contextPaths ?? [];
+    const pathStr = paths.length > 0 ? `
+    Context links: ${paths.map((p) => `${p.type}:${p.path}`).join(", ")}` : "";
+    return `  - ${t.name} (id: ${t.id})${t.description ? `: ${t.description}` : " [no description]"}${pathStr}
+    Active tasks: ${t.activeTaskCount}`;
+  }).join("\n");
+}
+function buildHeatmapSection(entries) {
+  if (entries.length === 0) return "No file read analytics data available.";
+  return entries.slice(0, 50).map((e) => {
+    const tagBreakdown = Object.entries(e.byTag).sort(([, a], [, b]) => b - a).map(([tag, count]) => `${tag}:${count}`).join(", ");
+    return `  ${e.filePath} \u2014 ${e.totalReads} reads${tagBreakdown ? ` (${tagBreakdown})` : ""}`;
+  }).join("\n");
+}
+function buildAuditSystemPrompt(projectName, tags, heatmapData, projectDir) {
+  return [
+    "You are a project organization expert analyzing tag taxonomy for a software project.",
+    "Tags are used to categorize tasks and link relevant documentation/rules/files to subsystems.",
+    "",
+    `PROJECT: ${projectName}`,
+    "",
+    `EXISTING TAGS (${tags.length}):`,
+    buildTagSection(tags),
+    "",
+    "FILE READ ANALYTICS (what agents actually read, by tag):",
+    buildHeatmapSection(heatmapData),
+    "",
+    `You have full access to the codebase at: ${projectDir}`,
+    "Use your file reading and searching tools to understand the codebase structure,",
+    "module boundaries, and architectural patterns before making recommendations.",
+    "",
+    "ANALYSIS TASKS:",
+    "1. Read actual source files to understand code areas and module boundaries",
+    "2. Search for imports, class definitions, and architectural patterns",
+    "3. Coverage: Are all major subsystems/services represented by tags?",
+    "4. Descriptions: Do all tags have clear, useful descriptions?",
+    "5. Context Links: Are relevant rules/docs/folders linked to tags via contextPaths?",
+    "6. Documentation Gaps: Which high-read files lack linked documentation?",
+    "7. Cleanup: Any tags that should be merged, renamed, or removed?",
+    "",
+    "Use the tag-audit MCP tools to submit each recommendation.",
+    "Call complete_audit when you are done with a thorough summary.",
+    "Be comprehensive \u2014 recommend all improvements your analysis supports.",
+    "Analyze actual file contents, not just file names."
+  ].join("\n");
+}
+async function runAuditQuery(request, connection, projectDir) {
+  let agentCtx = null;
+  try {
+    agentCtx = await connection.fetchAgentContext();
+  } catch {
+    logger5.warn("Could not fetch agent context for audit, using defaults");
+  }
+  const model = agentCtx?.model || FALLBACK_MODEL2;
+  const settings = agentCtx?.agentSettings ?? {};
+  const collector = {
+    recommendations: [],
+    summary: "Audit completed.",
+    complete: false
+  };
+  const systemPrompt = buildAuditSystemPrompt(
+    request.projectName,
+    request.tags,
+    request.fileHeatmap,
+    projectDir
+  );
+  const userPrompt = [
+    "Analyze the project's tag taxonomy and submit recommendations using the tag-audit MCP tools.",
+    `There are currently ${request.tags.length} tags configured.`,
+    request.fileHeatmap.length > 0 ? `File analytics show ${request.fileHeatmap.length} files with read activity.` : "No file read analytics available.",
+    "",
+    "Start by exploring the codebase structure, then analyze each tag for accuracy and completeness.",
+    "Call complete_audit when done."
+  ].join("\n");
+  const events = query3({
+    prompt: userPrompt,
+    options: {
+      model,
+      systemPrompt: { type: "preset", preset: "claude_code", append: systemPrompt },
+      cwd: projectDir,
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      tools: { type: "preset", preset: "claude_code" },
+      mcpServers: { "tag-audit": createAuditMcpServer(collector) },
+      maxTurns: settings.maxTurns ?? 30,
+      maxBudgetUsd: settings.maxBudgetUsd ?? 5,
+      effort: settings.effort,
+      thinking: settings.thinking
+    }
+  });
+  for await (const event of events) {
+    if (event.type === "result") break;
+  }
+  return collector;
+}
+async function handleProjectAuditRequest(request, connection, projectDir) {
+  connection.emitAgentStatus("busy");
+  try {
+    const collector = await runAuditQuery(request, connection, projectDir);
+    const result = {
+      recommendations: collector.recommendations,
+      summary: collector.summary,
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    logger5.info("Tag audit completed", {
+      requestId: request.requestId,
+      recommendationCount: result.recommendations.length
+    });
+    connection.emitAuditResult({ requestId: request.requestId, result });
+  } catch (error) {
+    logger5.error("Tag audit failed", {
+      requestId: request.requestId,
+      ...errorMeta(error)
+    });
+    connection.emitAuditResult({
+      requestId: request.requestId,
+      error: error instanceof Error ? error.message : "Tag audit failed"
+    });
+  } finally {
+    connection.emitAgentStatus("idle");
+  }
+}
+
 // src/runner/project-runner.ts
-var logger4 = createServiceLogger("ProjectRunner");
+var logger6 = createServiceLogger("ProjectRunner");
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
 var HEARTBEAT_INTERVAL_MS2 = 3e4;
 var MAX_CONCURRENT = Math.max(1, parseInt(process.env.CONVEYOR_MAX_CONCURRENT ?? "10", 10) || 10);
 var STOP_TIMEOUT_MS = 3e4;
+var START_CMD_KILL_TIMEOUT_MS = 5e3;
 function setupWorkDir(projectDir, assignment) {
   const { taskId, branch, devBranch, useWorktree } = assignment;
   const shortId = taskId.slice(0, 8);
@@ -3856,12 +4596,12 @@ function setupWorkDir(projectDir, assignment) {
   }
   if (branch && branch !== devBranch) {
     try {
-      execSync5(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
+      execSync6(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
     } catch {
       try {
-        execSync5(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
+        execSync6(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
       } catch {
-        logger4.warn("Could not checkout branch", { taskId: shortId, branch });
+        logger6.warn("Could not checkout branch", { taskId: shortId, branch });
       }
     }
   }
@@ -3900,13 +4640,13 @@ function spawnChildAgent(assignment, workDir) {
   child.stdout?.on("data", (data) => {
     const lines = data.toString().trimEnd().split("\n");
     for (const line of lines) {
-      logger4.info(line, { taskId: shortId });
+      logger6.info(line, { taskId: shortId });
     }
   });
   child.stderr?.on("data", (data) => {
     const lines = data.toString().trimEnd().split("\n");
     for (const line of lines) {
-      logger4.error(line, { taskId: shortId });
+      logger6.error(line, { taskId: shortId });
     }
   });
   return child;
@@ -3918,31 +4658,348 @@ var ProjectRunner = class {
   heartbeatTimer = null;
   stopping = false;
   resolveLifecycle = null;
+  // Start command process management
+  startCommandChild = null;
+  startCommandRunning = false;
+  setupComplete = false;
+  branchSwitchCommand;
+  commitWatcher;
   constructor(config) {
     this.projectDir = config.projectDir;
     this.connection = new ProjectConnection({
       apiUrl: config.conveyorApiUrl,
       projectToken: config.projectToken,
-      projectId: config.projectId
+      projectId: config.projectId,
+      projectDir: config.projectDir
     });
+    this.commitWatcher = new CommitWatcher(
+      {
+        projectDir: this.projectDir,
+        pollIntervalMs: Number(process.env.CONVEYOR_COMMIT_POLL_INTERVAL) || 1e4,
+        debounceMs: 3e3
+      },
+      {
+        onNewCommits: async (data) => {
+          this.connection.emitNewCommitsDetected({
+            branch: data.branch,
+            commitCount: data.commitCount,
+            latestCommit: {
+              sha: data.newCommitSha,
+              message: data.latestMessage,
+              author: data.latestAuthor
+            },
+            autoSyncing: true
+          });
+          const startTime = Date.now();
+          const stepsRun = await this.smartSync(data.previousSha, data.newCommitSha, data.branch);
+          this.connection.emitEnvironmentReady({
+            branch: data.branch,
+            commitsSynced: data.commitCount,
+            syncDurationMs: Date.now() - startTime,
+            stepsRun
+          });
+        }
+      }
+    );
   }
   checkoutWorkspaceBranch() {
     const workspaceBranch = process.env.CONVEYOR_WORKSPACE_BRANCH;
     if (!workspaceBranch) return;
     try {
-      execSync5(`git fetch origin ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
-      execSync5(`git checkout ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
-      logger4.info("Checked out workspace branch", { workspaceBranch });
+      execSync6(`git fetch origin ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
+      execSync6(`git checkout ${workspaceBranch}`, { cwd: this.projectDir, stdio: "pipe" });
+      logger6.info("Checked out workspace branch", { workspaceBranch });
     } catch (err) {
-      logger4.warn("Failed to checkout workspace branch, continuing on current branch", {
+      logger6.warn("Failed to checkout workspace branch, continuing on current branch", {
         workspaceBranch,
         ...errorMeta(err)
       });
     }
   }
+  async executeSetupCommand() {
+    const cmd = process.env.CONVEYOR_SETUP_COMMAND;
+    if (!cmd) return;
+    logger6.info("Running setup command", { command: cmd });
+    try {
+      await runSetupCommand(cmd, this.projectDir, (stream, data) => {
+        this.connection.emitEvent({ type: "setup_output", stream, data });
+        (stream === "stderr" ? process.stderr : process.stdout).write(data);
+      });
+      logger6.info("Setup command completed");
+    } catch (error) {
+      logger6.error("Setup command failed", errorMeta(error));
+      this.connection.emitEvent({
+        type: "setup_error",
+        message: error instanceof Error ? error.message : "Setup command failed"
+      });
+      throw error;
+    }
+  }
+  executeStartCommand() {
+    const cmd = process.env.CONVEYOR_START_COMMAND;
+    if (!cmd) return;
+    logger6.info("Running start command", { command: cmd });
+    const child = runStartCommand(cmd, this.projectDir, (stream, data) => {
+      this.connection.emitEvent({ type: "start_command_output", stream, data });
+      (stream === "stderr" ? process.stderr : process.stdout).write(data);
+    });
+    this.startCommandChild = child;
+    this.startCommandRunning = true;
+    child.on("exit", (code, signal) => {
+      this.startCommandRunning = false;
+      this.startCommandChild = null;
+      logger6.info("Start command exited", { code, signal });
+      this.connection.emitEvent({
+        type: "start_command_exited",
+        code,
+        signal,
+        message: `Start command exited with code ${code}`
+      });
+    });
+    child.on("error", (err) => {
+      this.startCommandRunning = false;
+      this.startCommandChild = null;
+      logger6.error("Start command error", errorMeta(err));
+    });
+  }
+  async killStartCommand() {
+    const child = this.startCommandChild;
+    if (!child || !this.startCommandRunning) return;
+    logger6.info("Killing start command");
+    try {
+      if (child.pid) process.kill(-child.pid, "SIGTERM");
+    } catch {
+      child.kill("SIGTERM");
+    }
+    await new Promise((resolve2) => {
+      const timer = setTimeout(() => {
+        if (this.startCommandRunning && child.pid) {
+          try {
+            process.kill(-child.pid, "SIGKILL");
+          } catch {
+            child.kill("SIGKILL");
+          }
+        }
+        resolve2();
+      }, START_CMD_KILL_TIMEOUT_MS);
+      child.on("exit", () => {
+        clearTimeout(timer);
+        resolve2();
+      });
+    });
+    this.startCommandChild = null;
+    this.startCommandRunning = false;
+  }
+  async restartStartCommand() {
+    await this.killStartCommand();
+    this.executeStartCommand();
+  }
+  getEnvironmentStatus() {
+    let currentBranch = "unknown";
+    try {
+      currentBranch = execSync6("git branch --show-current", {
+        cwd: this.projectDir,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString().trim();
+    } catch {
+    }
+    return {
+      setupComplete: this.setupComplete,
+      startCommandRunning: this.startCommandRunning,
+      currentBranch,
+      previewPort: Number(process.env.CONVEYOR_PREVIEW_PORT) || null
+    };
+  }
+  getCurrentBranch() {
+    try {
+      return execSync6("git branch --show-current", {
+        cwd: this.projectDir,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString().trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  // oxlint-disable-next-line max-lines-per-function, complexity -- sequential sync steps with per-step error handling
+  async smartSync(previousSha, newSha, branch) {
+    const stepsRun = [];
+    const status = execSync6("git status --porcelain", {
+      cwd: this.projectDir,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    if (status) {
+      this.connection.emitEvent({
+        type: "commit_watch_warning",
+        message: "Working tree has uncommitted changes. Auto-pull skipped."
+      });
+      return ["skipped:dirty_tree"];
+    }
+    await this.killStartCommand();
+    this.connection.emitEnvSwitchProgress({ step: "pull", status: "running" });
+    try {
+      execSync6(`git pull origin ${branch}`, {
+        cwd: this.projectDir,
+        stdio: "pipe",
+        timeout: 6e4
+      });
+      stepsRun.push("pull");
+      this.connection.emitEnvSwitchProgress({ step: "pull", status: "success" });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Pull failed";
+      this.connection.emitEnvSwitchProgress({ step: "pull", status: "error", message });
+      logger6.error("Git pull failed during commit sync", errorMeta(err));
+      this.executeStartCommand();
+      return ["error:pull"];
+    }
+    let changedFiles = [];
+    try {
+      changedFiles = execSync6(`git diff --name-only ${previousSha}..${newSha}`, {
+        cwd: this.projectDir,
+        stdio: ["ignore", "pipe", "ignore"]
+      }).toString().trim().split("\n").filter(Boolean);
+    } catch {
+    }
+    const needsInstall = changedFiles.some(
+      (f) => f === "package.json" || f === "bun.lockb" || f === "bunfig.toml" || f.endsWith("/package.json") || f.endsWith("/bun.lockb")
+    );
+    const needsPrisma = changedFiles.some(
+      (f) => f.includes("prisma/schema.prisma") || f.includes("prisma/migrations/")
+    );
+    const cmd = this.branchSwitchCommand ?? process.env.CONVEYOR_BRANCH_SWITCH_COMMAND;
+    if (cmd && (needsInstall || needsPrisma)) {
+      this.connection.emitEnvSwitchProgress({ step: "sync", status: "running" });
+      try {
+        await runSetupCommand(cmd, this.projectDir, (stream, data) => {
+          this.connection.emitEvent({ type: "sync_output", stream, data });
+        });
+        stepsRun.push("branchSwitchCommand");
+        this.connection.emitEnvSwitchProgress({ step: "sync", status: "success" });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Sync command failed";
+        this.connection.emitEnvSwitchProgress({ step: "sync", status: "error", message });
+        logger6.error("Branch switch command failed during commit sync", errorMeta(err));
+      }
+    } else if (!cmd) {
+      if (needsInstall) {
+        this.connection.emitEnvSwitchProgress({ step: "install", status: "running" });
+        try {
+          execSync6("bun install", { cwd: this.projectDir, timeout: 12e4, stdio: "pipe" });
+          stepsRun.push("install");
+          this.connection.emitEnvSwitchProgress({ step: "install", status: "success" });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Install failed";
+          this.connection.emitEnvSwitchProgress({ step: "install", status: "error", message });
+          logger6.error("bun install failed during commit sync", errorMeta(err));
+        }
+      }
+      if (needsPrisma) {
+        this.connection.emitEnvSwitchProgress({ step: "prisma", status: "running" });
+        try {
+          execSync6("bunx prisma generate", {
+            cwd: this.projectDir,
+            timeout: 6e4,
+            stdio: "pipe"
+          });
+          execSync6("bunx prisma db push --accept-data-loss", {
+            cwd: this.projectDir,
+            timeout: 6e4,
+            stdio: "pipe"
+          });
+          stepsRun.push("prisma");
+          this.connection.emitEnvSwitchProgress({ step: "prisma", status: "success" });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Prisma sync failed";
+          this.connection.emitEnvSwitchProgress({ step: "prisma", status: "error", message });
+          logger6.error("Prisma sync failed during commit sync", errorMeta(err));
+        }
+      }
+    }
+    this.executeStartCommand();
+    stepsRun.push("startCommand");
+    return stepsRun;
+  }
+  async handleSwitchBranch(data, callback) {
+    const { branch, syncAfter } = data;
+    try {
+      this.connection.emitEnvSwitchProgress({ step: "fetch", status: "running" });
+      try {
+        execSync6("git fetch origin", { cwd: this.projectDir, stdio: "pipe" });
+      } catch {
+        logger6.warn("Git fetch failed during branch switch");
+      }
+      this.connection.emitEnvSwitchProgress({ step: "fetch", status: "success" });
+      this.connection.emitEnvSwitchProgress({ step: "checkout", status: "running" });
+      try {
+        execSync6(`git checkout ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Checkout failed";
+        this.connection.emitEnvSwitchProgress({ step: "checkout", status: "error", message });
+        callback({ ok: false, error: `Failed to checkout branch: ${message}` });
+        return;
+      }
+      try {
+        execSync6(`git pull origin ${branch}`, { cwd: this.projectDir, stdio: "pipe" });
+      } catch {
+        logger6.warn("Git pull failed during branch switch", { branch });
+      }
+      this.connection.emitEnvSwitchProgress({ step: "checkout", status: "success" });
+      if (syncAfter !== false) {
+        await this.handleSyncEnvironment();
+      }
+      this.commitWatcher.start(branch);
+      callback({ ok: true, data: this.getEnvironmentStatus() });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Branch switch failed";
+      logger6.error("Branch switch failed", errorMeta(err));
+      callback({ ok: false, error: message });
+    }
+  }
+  async handleSyncEnvironment(callback) {
+    try {
+      await this.killStartCommand();
+      const cmd = this.branchSwitchCommand ?? process.env.CONVEYOR_BRANCH_SWITCH_COMMAND;
+      if (cmd) {
+        this.connection.emitEnvSwitchProgress({ step: "sync", status: "running" });
+        try {
+          await runSetupCommand(cmd, this.projectDir, (stream, data) => {
+            this.connection.emitEvent({ type: "sync_output", stream, data });
+            (stream === "stderr" ? process.stderr : process.stdout).write(data);
+          });
+          this.connection.emitEnvSwitchProgress({ step: "sync", status: "success" });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Sync command failed";
+          this.connection.emitEnvSwitchProgress({ step: "sync", status: "error", message });
+          logger6.error("Branch switch sync command failed", errorMeta(err));
+        }
+      }
+      this.executeStartCommand();
+      this.connection.emitEnvSwitchProgress({ step: "startCommand", status: "success" });
+      callback?.({ ok: true, data: this.getEnvironmentStatus() });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Sync failed";
+      logger6.error("Environment sync failed", errorMeta(err));
+      callback?.({ ok: false, error: message });
+    }
+  }
+  handleGetEnvStatus(callback) {
+    callback({ ok: true, data: this.getEnvironmentStatus() });
+  }
   async start() {
     this.checkoutWorkspaceBranch();
     await this.connection.connect();
+    try {
+      await this.executeSetupCommand();
+      this.executeStartCommand();
+      this.setupComplete = true;
+      this.connection.emitEvent({
+        type: "setup_complete",
+        previewPort: Number(process.env.CONVEYOR_PREVIEW_PORT) || void 0,
+        startCommandRunning: this.startCommandRunning
+      });
+    } catch (error) {
+      logger6.error("Environment setup failed", errorMeta(error));
+      this.setupComplete = false;
+    }
     this.connection.onTaskAssignment((assignment) => {
       this.handleAssignment(assignment);
     });
@@ -3950,17 +5007,40 @@ var ProjectRunner = class {
       this.handleStopTask(data.taskId);
     });
     this.connection.onShutdown(() => {
-      logger4.info("Received shutdown signal from server");
+      logger6.info("Received shutdown signal from server");
       void this.stop();
     });
     this.connection.onChatMessage((msg) => {
-      logger4.debug("Received project chat message");
+      logger6.debug("Received project chat message");
       void handleProjectChatMessage(msg, this.connection, this.projectDir);
     });
+    this.connection.onAuditRequest((request) => {
+      logger6.debug("Received tag audit request", { requestId: request.requestId });
+      void handleProjectAuditRequest(request, this.connection, this.projectDir);
+    });
+    this.connection.onSwitchBranch = (data, cb) => {
+      void this.handleSwitchBranch(data, cb);
+    };
+    this.connection.onSyncEnvironment = (cb) => {
+      void this.handleSyncEnvironment(cb);
+    };
+    this.connection.onGetEnvStatus = (cb) => {
+      this.handleGetEnvStatus(cb);
+    };
+    try {
+      const context = await this.connection.fetchAgentContext();
+      this.branchSwitchCommand = context?.branchSwitchCommand ?? process.env.CONVEYOR_BRANCH_SWITCH_COMMAND;
+    } catch {
+      this.branchSwitchCommand = process.env.CONVEYOR_BRANCH_SWITCH_COMMAND;
+    }
     this.heartbeatTimer = setInterval(() => {
       this.connection.sendHeartbeat();
     }, HEARTBEAT_INTERVAL_MS2);
-    logger4.info("Connected, waiting for task assignments");
+    const currentBranch = this.getCurrentBranch();
+    if (currentBranch) {
+      this.commitWatcher.start(currentBranch);
+    }
+    logger6.info("Connected, waiting for task assignments");
     await new Promise((resolve2) => {
       this.resolveLifecycle = resolve2;
       process.on("SIGTERM", () => void this.stop());
@@ -3971,11 +5051,11 @@ var ProjectRunner = class {
     const { taskId, mode } = assignment;
     const shortId = taskId.slice(0, 8);
     if (this.activeAgents.has(taskId)) {
-      logger4.info("Task already running, skipping", { taskId: shortId });
+      logger6.info("Task already running, skipping", { taskId: shortId });
       return;
     }
     if (this.activeAgents.size >= MAX_CONCURRENT) {
-      logger4.warn("Max concurrent agents reached, rejecting task", {
+      logger6.warn("Max concurrent agents reached, rejecting task", {
         maxConcurrent: MAX_CONCURRENT,
         taskId: shortId
       });
@@ -3984,9 +5064,9 @@ var ProjectRunner = class {
     }
     try {
       try {
-        execSync5("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
+        execSync6("git fetch origin", { cwd: this.projectDir, stdio: "ignore" });
       } catch {
-        logger4.warn("Git fetch failed", { taskId: shortId });
+        logger6.warn("Git fetch failed", { taskId: shortId });
       }
       const { workDir, usesWorktree } = setupWorkDir(this.projectDir, assignment);
       const child = spawnChildAgent(assignment, workDir);
@@ -3997,12 +5077,12 @@ var ProjectRunner = class {
         usesWorktree
       });
       this.connection.emitTaskStarted(taskId);
-      logger4.info("Started task", { taskId: shortId, mode, workDir });
+      logger6.info("Started task", { taskId: shortId, mode, workDir });
       child.on("exit", (code) => {
         this.activeAgents.delete(taskId);
         const reason = code === 0 ? "completed" : `exited with code ${code}`;
         this.connection.emitTaskStopped(taskId, reason);
-        logger4.info("Task exited", { taskId: shortId, reason });
+        logger6.info("Task exited", { taskId: shortId, reason });
         if (code === 0 && usesWorktree) {
           try {
             removeWorktree(this.projectDir, taskId);
@@ -4011,7 +5091,7 @@ var ProjectRunner = class {
         }
       });
     } catch (error) {
-      logger4.error("Failed to start task", {
+      logger6.error("Failed to start task", {
         taskId: shortId,
         ...errorMeta(error)
       });
@@ -4025,7 +5105,7 @@ var ProjectRunner = class {
     const agent = this.activeAgents.get(taskId);
     if (!agent) return;
     const shortId = taskId.slice(0, 8);
-    logger4.info("Stopping task", { taskId: shortId });
+    logger6.info("Stopping task", { taskId: shortId });
     agent.process.kill("SIGTERM");
     const timer = setTimeout(() => {
       if (this.activeAgents.has(taskId)) {
@@ -4045,7 +5125,9 @@ var ProjectRunner = class {
   async stop() {
     if (this.stopping) return;
     this.stopping = true;
-    logger4.info("Shutting down");
+    logger6.info("Shutting down");
+    this.commitWatcher.stop();
+    await this.killStartCommand();
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
@@ -4070,7 +5152,7 @@ var ProjectRunner = class {
       })
     ]);
     this.connection.disconnect();
-    logger4.info("Shutdown complete");
+    logger6.info("Shutdown complete");
     if (this.resolveLifecycle) {
       this.resolveLifecycle();
       this.resolveLifecycle = null;
@@ -4156,4 +5238,4 @@ export {
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-N3TSLBSH.js.map
+//# sourceMappingURL=chunk-MRTSBPY7.js.map