@rallycry/conveyor-agent 8.4.1 → 8.5.1

package/dist/{chunk-B4QHEMMV.js → chunk-WZCO64YR.js}

@@ -5,13 +5,14 @@ import {
   textResult
 } from "./chunk-FDWECEDJ.js";
 import {
+  configHomePlansDir,
   createHarness,
   createServiceLogger,
   defineTool,
   ensureClaudeCredentials,
   removeConveyorCredentials,
   sessionTranscriptPath
-} from "./chunk-VDH55LTT.js";
+} from "./chunk-6B545CHM.js";
 
 // src/setup/bootstrap.ts
 var BOOTSTRAP_TIMEOUT_MS = 3e4;
@@ -133,11 +134,13 @@ function applyBootstrapToEnv(config) {
 import { io } from "socket.io-client";
 var EVENT_BATCH_MS = 500;
 var MAX_EVENT_BUFFER = 5e3;
+var TOKEN_REFRESH_INTERVAL_MS = 6 * 60 * 60 * 1e3;
 var AgentConnection = class _AgentConnection {
   socket = null;
   config;
   eventBuffer = [];
   flushTimer = null;
+  tokenRefreshTimer = null;
   lastEmittedStatus = null;
   lastReportedStatus = null;
   droppedEventCount = 0;
@@ -201,6 +204,7 @@ var AgentConnection = class _AgentConnection {
     if (!this.config.apiUrl) {
       return Promise.reject(new Error("Cannot connect: apiUrl is empty"));
     }
+    this.startProactiveTokenRefresh();
     return new Promise((resolve2, reject) => {
       let settled = false;
       let attempts = 0;
@@ -227,7 +231,8 @@ var AgentConnection = class _AgentConnection {
           content: msg.content,
           userId: msg.userId,
           ...msg.source && { source: msg.source },
-          ...msg.files && { files: msg.files }
+          ...msg.files && { files: msg.files },
+          ...msg.delivery === "prefill" && { delivery: msg.delivery }
         };
         if (this.messageCallback) this.messageCallback(incoming);
         else this.earlyMessages.push(incoming);
@@ -314,6 +319,7 @@ var AgentConnection = class _AgentConnection {
     });
   }
   disconnect() {
+    this.stopProactiveTokenRefresh();
     void this.flushEvents();
     if (this.socket) {
       this.socket.io.reconnection(false);
@@ -397,7 +403,32 @@ var AgentConnection = class _AgentConnection {
     }
   }
   looksLikeAuthError(message) {
-    return /unauthor|forbid|auth|token/i.test(message);
+    return /unauthor|forbid|auth|token|session (?:not found|expired|invalid)|invalid session/i.test(
+      message
+    );
+  }
+  // ── Proactive task-token refresh ────────────────────────────────────────
+  //
+  // Socket.IO only re-presents the taskToken on a (re)connect handshake, and
+  // the server only re-validates the JWT then. So a token that expires while
+  // the socket stays connected goes unnoticed until the next RPC fails. Re-mint
+  // periodically from the bootstrap endpoint — refreshFromBootstrap() updates
+  // both this.config.taskToken and socket.auth.taskToken, so any later
+  // reconnect carries a fresh token. No-ops for project mode / missing
+  // codespace env, and is rate-limited to once/60s inside refreshFromBootstrap.
+  startProactiveTokenRefresh() {
+    if (this.tokenRefreshTimer) return;
+    this.tokenRefreshTimer = setInterval(() => {
+      void this.refreshTaskTokenFromBootstrap().catch(() => {
+      });
+    }, TOKEN_REFRESH_INTERVAL_MS);
+    this.tokenRefreshTimer.unref?.();
+  }
+  stopProactiveTokenRefresh() {
+    if (this.tokenRefreshTimer) {
+      clearInterval(this.tokenRefreshTimer);
+      this.tokenRefreshTimer = null;
+    }
   }
   drainPendingMessages(messages) {
     for (const msg of messages) {
@@ -1316,7 +1347,7 @@ var PlanSync = class {
     this.workspaceDir = workspaceDir;
   }
   getPlanDirs() {
-    return [join(this.workspaceDir, ".claude", "plans")];
+    return [join(this.workspaceDir, ".claude", "plans"), configHomePlansDir()];
   }
   snapshotPlanFiles() {
     this.planFileSnapshot.clear();
@@ -1934,6 +1965,11 @@ var StopProjectBuildRequestSchema = z2.object({
   taskId: z2.string(),
   requestingUserId: z2.string().optional()
 });
+var CreateProjectReleaseRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskIds: z2.array(z2.string()).optional(),
+  requestingUserId: z2.string().optional()
+});
 var ApproveProjectMergePRRequestSchema = z2.object({
   projectId: z2.string(),
   childTaskId: z2.string(),
@@ -2009,6 +2045,22 @@ var GetProjectAttachmentRequestSchema = z2.object({
   /** Max bytes of text content to return from `offset`. Server default applies. */
   maxBytes: z2.number().int().positive().optional()
 });
+var RequestProjectFileUploadRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  fileName: z2.string().min(1).max(255),
+  mimeType: z2.string().min(1).max(128),
+  fileSize: z2.number().int().positive().max(MAX_FILE_SIZE_BYTES),
+  requestingUserId: z2.string().optional()
+});
+var ConfirmProjectFileUploadRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  fileId: z2.string(),
+  /** When set, the attachment is also posted to the task chat with this text. */
+  comment: z2.string().max(2e3).optional(),
+  requestingUserId: z2.string().optional()
+});
 var CreateProjectPullRequestRequestSchema = z2.object({
   projectId: z2.string(),
   taskId: z2.string(),
@@ -2033,6 +2085,16 @@ var RemoveProjectTaskReviewerRequestSchema = z2.object({
   userId: z2.string(),
   requestingUserId: z2.string().optional()
 });
+var ListProjectManualTestsRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string()
+});
+var SetProjectManualTestsRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  items: z2.array(z2.object({ title: z2.string().min(1) })).min(1),
+  requestingUserId: z2.string().optional()
+});
 var StartTaskAuditRequestSchema = z3.object({
   projectId: z3.string(),
   taskIds: z3.array(z3.string()).min(1)
@@ -6259,7 +6321,11 @@ async function handleExitPlanMode(host, input) {
       await host.connection.postChatMessageAwait(
         "Planning complete \u2014 awaiting team approval. Icon and agent assignment will be set automatically."
       );
-      host.requestStop();
+      if (host.harnessKind === "pty") {
+        setTimeout(() => host.requestStop(), 250);
+      } else {
+        host.requestStop();
+      }
       return { behavior: "allow", updatedInput: input };
     }
     try {
@@ -6533,9 +6599,10 @@ function repairTornSessionFile(path2) {
 }
 function resolvePromptDelivery(inputs) {
   if (inputs.harnessKind !== "pty") return "submit";
-  if ((inputs.runnerMode ?? "task") !== "task") return "submit";
+  if (inputs.runnerMode === "code-review") return "submit";
   if (inputs.isFollowUp || inputs.hasExistingSession) return "submit";
   if (inputs.isAuto || inputs.agentMode === "auto") return "submit";
+  if (inputs.agentMode !== "discovery" && inputs.agentMode !== "help") return "submit";
   return "prefill";
 }
 function isReadOnlyMode(mode, hasExitedPlanMode) {
@@ -6572,6 +6639,14 @@ function buildQueryOptions(host, context) {
     permissionMode: needsCanUseTool ? "plan" : "bypassPermissions",
     allowDangerouslySkipPermissions: !needsCanUseTool,
     canUseTool: buildCanUseTool(host),
+    // The spawned CLI never sees `systemPrompt` (an SDK-only option) — deliver
+    // the same text via `--append-system-prompt`. PTY-only: the SDK harness
+    // already receives it through systemPrompt.append.
+    ...host.harnessKind === "pty" && systemPromptText ? { appendSystemPrompt: systemPromptText } : {},
+    // Auto mode pre-exit: after the ExitPlanMode hook allows the call, the
+    // CLI's plan dialog still renders — press Enter so the autonomous agent
+    // continues building in the same session (Conveyor validated in the hook).
+    planDialogAutoAccept: mode === "auto" && !host.hasExitedPlanMode,
     tools: { type: "preset", preset: "claude_code" },
     mcpServers: {
       conveyor: createConveyorMcpServer(host.harness, host.connection, host.config, context, mode)
@@ -6712,13 +6787,7 @@ async function runSdkQuery(host, context, followUpContent, promptDeliveryOverrid
   };
   const resume = hasExistingSession ? sessionUuid : void 0;
   if (followUpContent) {
-    const prompt = await buildFollowUpPrompt(host, context, followUpContent);
-    const agentQuery = host.harness.executeQuery({
-      prompt: typeof prompt === "string" ? prompt : host.createInputStream(prompt),
-      options: { ...options },
-      resume
-    });
-    await trackAndRun(host, context, options, agentQuery);
+    await runFollowUpQuery(host, context, options, resume, followUpContent);
   } else if (isDiscoveryLike && promptDelivery !== "prefill") {
     return;
   } else {
@@ -6728,6 +6797,42 @@ async function runSdkQuery(host, context, followUpContent, promptDeliveryOverrid
     await host.syncPlanFile();
   }
 }
+async function runFollowUpQuery(host, context, options, resume, followUpContent) {
+  if (options.promptDelivery === "prefill") {
+    await runPrefilledFollowUp(host, context, options, resume, followUpContent);
+    return;
+  }
+  const prompt = await buildFollowUpPrompt(host, context, followUpContent);
+  const agentQuery = host.harness.executeQuery({
+    prompt: typeof prompt === "string" ? prompt : host.createInputStream(prompt),
+    options: { ...options },
+    resume
+  });
+  await trackAndRun(host, context, options, agentQuery);
+}
+async function runPrefilledFollowUp(host, context, options, resume, followUpContent) {
+  const followUpText = typeof followUpContent === "string" ? followUpContent : followUpContent.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+  const queryOptions = { ...options };
+  if (host.config.mode === "pm" && !resume) {
+    const initialPrompt = await buildInitialPrompt(
+      host.config.mode,
+      context,
+      host.isAuto,
+      host.agentMode
+    );
+    queryOptions.appendSystemPrompt = [queryOptions.appendSystemPrompt, initialPrompt].filter(Boolean).join("\n\n").slice(0, APPEND_SYSTEM_PROMPT_MAX_CHARS);
+  }
+  let agentQuery = host.harness.executeQuery({
+    prompt: followUpText,
+    options: queryOptions,
+    resume
+  });
+  agentQuery = notifyOnFirstEvent(agentQuery, async () => {
+    host.connection.emitStatus("running");
+    await host.callbacks.onStatusChange("running");
+  });
+  await trackAndRun(host, context, queryOptions, agentQuery);
+}
 async function trackAndRun(host, context, options, agentQuery) {
   if (host.harnessKind === "pty" && options.promptDelivery !== "prefill") {
     agentQuery = watchForParkedTui(agentQuery, host);
@@ -6739,6 +6844,14 @@ async function trackAndRun(host, context, options, agentQuery) {
     host.activeQuery = null;
   }
 }
+var APPEND_SYSTEM_PROMPT_MAX_CHARS = 96e3;
+function latestUserMessageText(context) {
+  for (let i = context.chatHistory.length - 1; i >= 0; i--) {
+    const msg = context.chatHistory[i];
+    if (msg.role === "user" && msg.content.trim()) return msg.content.trim();
+  }
+  return null;
+}
 async function runInitialQuery(host, context, options, resume, promptDelivery) {
   const initialPrompt = await buildInitialPrompt(
     host.config.mode,
@@ -6746,10 +6859,18 @@ async function runInitialQuery(host, context, options, resume, promptDelivery) {
     host.isAuto,
     host.agentMode
   );
-  const prompt = buildMultimodalPrompt(initialPrompt, context);
+  let prompt;
+  const queryOptions = { ...options };
+  const prefillMessage = promptDelivery === "prefill" ? latestUserMessageText(context) : null;
+  if (prefillMessage) {
+    prompt = prefillMessage;
+    queryOptions.appendSystemPrompt = [queryOptions.appendSystemPrompt, initialPrompt].filter(Boolean).join("\n\n").slice(0, APPEND_SYSTEM_PROMPT_MAX_CHARS);
+  } else {
+    prompt = buildMultimodalPrompt(initialPrompt, context);
+  }
   let agentQuery = host.harness.executeQuery({
     prompt: host.createInputStream(prompt),
-    options: { ...options },
+    options: queryOptions,
     resume
   });
   if (promptDelivery === "prefill") {
@@ -6758,7 +6879,7 @@ async function runInitialQuery(host, context, options, resume, promptDelivery) {
       await host.callbacks.onStatusChange("running");
     });
   }
-  await trackAndRun(host, context, options, agentQuery);
+  await trackAndRun(host, context, queryOptions, agentQuery);
 }
 async function buildRetryQuery(host, context, options, lastErrorWasImage) {
   if (lastErrorWasImage) {
@@ -7111,6 +7232,7 @@ var QueryBridge = class {
   runnerConfig;
   callbacks;
   harness;
+  /** Which harness drives this bridge ("pty" task chat vs "sdk" rollback). */
   harnessKind;
   costTracker;
   planSync;
@@ -7516,10 +7638,13 @@ var SessionRunner = class _SessionRunner {
     this.queryBridge = this.createQueryBridge();
     await this.seedCostTrackerFromServer();
     this.logInitialization();
-    const staleMessageCount = this.pendingMessages.length;
+    const staleBatch = [...this.pendingMessages];
     const didExecuteInitialQuery = await this.executeInitialMode();
-    if (staleMessageCount > 0 && didExecuteInitialQuery) {
-      this.pendingMessages.splice(0, staleMessageCount);
+    if (staleBatch.length > 0 && didExecuteInitialQuery) {
+      for (const stale of staleBatch) {
+        const idx = this.pendingMessages.indexOf(stale);
+        if (idx !== -1) this.pendingMessages.splice(idx, 1);
+      }
     }
     if (this.queryBridge?.isDiscoveryCompleted) {
       process.stderr.write(
@@ -7567,14 +7692,18 @@ var SessionRunner = class _SessionRunner {
           }
           break;
         }
-        await this.setState("running");
         this.interrupted = false;
         await this.callbacks.onEvent({
           type: "user_message",
           content: msg.content,
           userId: msg.userId
         });
-        await this.executeQuery(msg.content);
+        if (this.prefillEligible(msg)) {
+          await this.runPrefilledMessage(msg, this.mode.effectiveMode);
+        } else {
+          await this.setState("running");
+          await this.executeQuery(msg.content);
+        }
         if (this.queryBridge?.isDiscoveryCompleted) {
           process.stderr.write(
             "[conveyor-agent] Discovery completed \u2014 entering dormant idle (staying connected)\n"
@@ -7647,7 +7776,13 @@ var SessionRunner = class _SessionRunner {
   async executeInitialMode() {
     if (!this.taskContext || !this.fullContext) return false;
     const effectiveMode = this.mode.effectiveMode;
-    const delivery = this.pendingMessages.length > 0 ? "submit" : this.queryBridge?.initialPromptDelivery(this.fullContext) ?? "submit";
+    const intrinsicDelivery = this.queryBridge?.initialPromptDelivery(this.fullContext) ?? "submit";
+    const hinted = this.prepareInitialPendingMessages(intrinsicDelivery);
+    if (hinted) {
+      await this.runPrefilledMessage(hinted, effectiveMode);
+      return true;
+    }
+    const delivery = this.pendingMessages.length > 0 ? "submit" : intrinsicDelivery;
     const shouldRun = effectiveMode === "building" || effectiveMode === "auto" || effectiveMode === "review" || delivery === "prefill";
     if (!shouldRun) {
       await this.setState("idle");
@@ -7674,6 +7809,88 @@ var SessionRunner = class _SessionRunner {
     if (!this.stopped) await this.setState("idle");
     return true;
   }
+  // ── Prefill-delivery helpers ───────────────────────────────────────
+  /**
+   * Startup-queue preamble: the card's initial message reaches a fresh pod
+   * twice — inside the task context (chat history) AND as a queued pending
+   * message. When the intrinsic delivery is prefill (manual-mode fresh TUI)
+   * or a hinted message is queued (Refine), drop those context-duplicates so
+   * they don't force submit semantics — a genuinely-new live message still
+   * does. Returns the lone hinted message to park, if any.
+   */
+  prepareInitialPendingMessages(intrinsicDelivery) {
+    const hasHintedPending = this.pendingMessages.some((m) => m.delivery === "prefill");
+    if (this.pendingMessages.length > 0 && (intrinsicDelivery === "prefill" || hasHintedPending)) {
+      this.foldContextDuplicatePendingMessages();
+    }
+    return this.takePrefillHintedMessage();
+  }
+  /**
+   * Drop pending messages whose content is already present as a user message
+   * in the task-context chat history (the card's initial message is delivered
+   * both ways). Hinted (prefill) messages are kept — they are consumed by the
+   * dedicated prefill path.
+   */
+  foldContextDuplicatePendingMessages() {
+    const userContents = new Set(
+      (this.fullContext?.chatHistory ?? []).filter((m) => m.role === "user" && m.content.trim()).map((m) => m.content.trim())
+    );
+    const kept = this.pendingMessages.filter(
+      (m) => m.delivery === "prefill" || !m.content.trim() || !userContents.has(m.content.trim())
+    );
+    const dropped = this.pendingMessages.length - kept.length;
+    if (dropped > 0) {
+      this.pendingMessages.length = 0;
+      this.pendingMessages.push(...kept);
+      process.stderr.write(
+        `[conveyor-agent] Folded ${dropped} pending message(s) already present in chat context
+`
+      );
+    }
+  }
+  /**
+   * Honor a prefill hint only when it is unambiguous: PTY harness, a manual
+   * (human-facing) agent mode, no other message queued behind it, and not an
+   * automated-critical source. Everything else keeps submit semantics.
+   */
+  prefillEligible(msg) {
+    if (msg.delivery !== "prefill") return false;
+    if (this.pendingMessages.length > 0) return false;
+    if (this.queryBridge?.harnessKind !== "pty") return false;
+    if (msg.source && msg.source !== "mode_change" && msg.source !== "user") return false;
+    const m = this.mode.effectiveMode;
+    return m === "discovery" || m === "review" || m === "help";
+  }
+  /** Consume the sole pending message when it should park as a prefill. */
+  takePrefillHintedMessage() {
+    if (this.pendingMessages.length !== 1) return null;
+    const [first] = this.pendingMessages;
+    if (!first || first.delivery !== "prefill") return null;
+    this.pendingMessages.length = 0;
+    if (this.prefillEligible(first)) return first;
+    this.pendingMessages.push(first);
+    return null;
+  }
+  /**
+   * Park a message in the Connected-TUI input (prefill) and wait for the human
+   * to submit. Empty content prefills the mode's initial prompt instead (the
+   * latest user chat message — e.g. a Refine wake on a dormant agent). The
+   * caller restores the idle state afterwards.
+   */
+  async runPrefilledMessage(msg, effectiveMode) {
+    await this.setState("waiting_for_input");
+    await this.callbacks.onEvent({
+      type: "execute_mode",
+      mode: effectiveMode,
+      delivery: "prefill"
+    });
+    this.lifecycle.startIdleTimer();
+    try {
+      await this.executeQuery(msg.content.trim() ? msg.content : void 0, "prefill");
+    } finally {
+      this.lifecycle.cancelIdleTimer();
+    }
+  }
   // ── Message waiting ────────────────────────────────────────────────
   waitForMessage() {
     if (this.pendingMessages.length > 0) {
@@ -8043,7 +8260,10 @@ var SessionRunner = class _SessionRunner {
 `);
     this.connection.sendEvent({ type: "shutdown", reason: finalState });
     this.lifecycle.destroy();
-    await this.setState(finalState);
+    try {
+      await this.setState(finalState);
+    } catch {
+    }
     this.connection.disconnect();
     this._finalState = finalState;
   }
@@ -8102,20 +8322,31 @@ var ProjectConnection = class {
     return this.socket?.connected ?? false;
   }
   // ── Typed service method call ──────────────────────────────────────────
-  call(method, payload) {
+  call(method, payload, opts) {
     const socket = this.requireSocket();
     return new Promise((resolve2, reject) => {
-      socket.emit(
-        `agentSessionService:${String(method)}`,
-        payload,
-        (response) => {
-          if (response.success && response.data !== void 0) {
-            resolve2(response.data);
-          } else {
-            reject(new Error(response.error ?? `Service call failed: ${String(method)}`));
-          }
+      const handleResponse = (response) => {
+        if (response.success && response.data !== void 0) {
+          resolve2(response.data);
+        } else {
+          reject(new Error(response.error ?? `Service call failed: ${String(method)}`));
         }
-      );
+      };
+      if (opts?.timeoutMs) {
+        socket.timeout(opts.timeoutMs).emit(
+          `agentSessionService:${String(method)}`,
+          payload,
+          (err, response) => {
+            if (err) {
+              reject(new Error(`Service call timed out: ${String(method)}`));
+            } else {
+              handleResponse(response);
+            }
+          }
+        );
+        return;
+      }
+      socket.emit(`agentSessionService:${String(method)}`, payload, handleResponse);
     });
   }
   // ── Connection lifecycle ───────────────────────────────────────────────
@@ -8173,8 +8404,13 @@ var ProjectConnection = class {
       this.flushTimer = null;
     }
     this.flushEvents();
-    this.socket?.disconnect();
-    this.socket = null;
+    if (this.socket) {
+      this.socket.io.reconnection(false);
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    this.reconnectCallbacks = [];
   }
   onReconnect(callback) {
     this.reconnectCallbacks.push(callback);
@@ -9771,6 +10007,10 @@ function spawnChildAgent(assignment, workDir) {
       CONVEYOR_MODE: mode,
       CONVEYOR_WORKSPACE: workDir,
       CONVEYOR_USE_WORKTREE: "false",
+      // The project runner flushes git for every child working tree after the
+      // kill (see ProjectRunner.stop), so the child skips its own shutdown
+      // flush — keeps SIGTERM teardown well inside the SIGKILL window.
+      CONVEYOR_SKIP_SHUTDOWN_GIT_FLUSH: "true",
       CONVEYOR_AGENT_MODE: effectiveAgentMode,
       CONVEYOR_IS_AUTO: isAuto ? "true" : "false",
       CONVEYOR_USE_SANDBOX: useSandbox === true ? "true" : "false",
@@ -9895,6 +10135,8 @@ function handleStopTask(taskId, activeAgents, projectDir) {
 // src/runner/project-runner.ts
 var logger10 = createServiceLogger("ProjectRunner");
 var HEARTBEAT_INTERVAL_MS = 3e4;
+var DISCONNECT_ACK_TIMEOUT_MS = 5e3;
+var SHUTDOWN_WATCHDOG_MS = 9e4;
 var ProjectRunner = class {
   connection;
   projectDir;
@@ -9978,11 +10220,17 @@ var ProjectRunner = class {
   }
   /** Best-effort WIP commit + push of every tracked working tree on shutdown.
    *  Iterates the main project dir plus any active agent worktrees so nothing
-   *  pending is lost when the pod is killed. Never throws. */
-  async flushGitOnShutdown() {
-    const dirs = /* @__PURE__ */ new Set([this.projectDir]);
-    for (const agent of this.activeAgents.values()) {
-      if (agent.worktreePath) dirs.add(agent.worktreePath);
+   *  pending is lost when the pod is killed. Never throws.
+   *
+   *  Callers that kill child agents first must snapshot the worktree dirs
+   *  BEFORE the kill — the child exit handler removes entries from
+   *  `activeAgents`, so reading it after the kill misses the worktrees. */
+  async flushGitOnShutdown(dirs) {
+    if (!dirs) {
+      dirs = /* @__PURE__ */ new Set([this.projectDir]);
+      for (const agent of this.activeAgents.values()) {
+        if (agent.worktreePath) dirs.add(agent.worktreePath);
+      }
     }
     for (const dir of dirs) {
       try {
@@ -10006,38 +10254,62 @@ var ProjectRunner = class {
     if (this.stopping) return;
     this.stopping = true;
     logger10.info("Shutting down");
-    this.commitWatcher.stop();
-    await killStartCommand(this.startCmd);
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
+    const watchdog = setTimeout(() => {
+      logger10.warn("Shutdown watchdog fired, forcing lifecycle resolution");
+      this.finishShutdown();
+    }, SHUTDOWN_WATCHDOG_MS);
+    watchdog.unref();
+    const flushDirs = /* @__PURE__ */ new Set([this.projectDir]);
+    for (const agent of this.activeAgents.values()) {
+      if (agent.worktreePath) flushDirs.add(agent.worktreePath);
     }
-    const stopPromises = [...this.activeAgents.keys()].map(
-      (key) => new Promise((resolve2) => {
-        const agent = this.activeAgents.get(key);
-        if (!agent) {
-          resolve2();
-          return;
-        }
-        agent.process.on("exit", () => resolve2());
-        handleStopTask(key, this.activeAgents, this.projectDir);
-      })
-    );
-    await Promise.race([
-      Promise.all(stopPromises),
-      new Promise((resolve2) => {
-        setTimeout(resolve2, STOP_TIMEOUT_MS + 5e3);
-      })
-    ]);
-    await this.flushGitOnShutdown();
     try {
-      await this.connection.call("disconnectProjectRunner", {
-        projectId: this.connection.projectId
-      });
+      this.commitWatcher.stop();
+      await killStartCommand(this.startCmd);
+      if (this.heartbeatTimer) {
+        clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+      }
+      const stopPromises = [...this.activeAgents.keys()].map(
+        (key) => new Promise((resolve2) => {
+          const agent = this.activeAgents.get(key);
+          if (!agent) {
+            resolve2();
+            return;
+          }
+          agent.process.on("exit", () => resolve2());
+          handleStopTask(key, this.activeAgents, this.projectDir);
+        })
+      );
+      await Promise.race([
+        Promise.all(stopPromises),
+        new Promise((resolve2) => {
+          setTimeout(resolve2, STOP_TIMEOUT_MS + 5e3);
+        })
+      ]);
+      await this.flushGitOnShutdown(flushDirs);
+      try {
+        await this.connection.call(
+          "disconnectProjectRunner",
+          { projectId: this.connection.projectId },
+          { timeoutMs: DISCONNECT_ACK_TIMEOUT_MS }
+        );
+      } catch {
+      }
+      logger10.info("Shutdown complete");
+    } finally {
+      clearTimeout(watchdog);
+      this.finishShutdown();
+    }
+  }
+  /** Idempotent final step: tear down the socket and resolve the lifecycle
+   *  promise so start() returns. Called from stop()'s finally and from the
+   *  shutdown watchdog. */
+  finishShutdown() {
+    try {
+      this.connection.disconnect();
     } catch {
     }
-    this.connection.disconnect();
-    logger10.info("Shutdown complete");
     if (this.resolveLifecycle) {
       this.resolveLifecycle();
       this.resolveLifecycle = null;
@@ -10111,7 +10383,7 @@ var ProjectRunner = class {
   async handleAuditTags(request) {
     this.connection.emitStatus("busy");
     try {
-      const { handleTagAudit } = await import("./tag-audit-handler-SWVMCAJH.js");
+      const { handleTagAudit } = await import("./tag-audit-handler-3IFB7YDV.js");
       await handleTagAudit(request, this.connection, this.projectDir);
     } catch (error) {
       const msg = parseErrorMessage(error);
@@ -10134,7 +10406,7 @@ var ProjectRunner = class {
   async handleAuditTasks(request) {
     this.connection.emitStatus("busy");
     try {
-      const { handleTaskAudit } = await import("./task-audit-handler-CZ2WWJFO.js");
+      const { handleTaskAudit } = await import("./task-audit-handler-U5Q52YT2.js");
       await handleTaskAudit(request, this.connection, this.projectDir);
     } catch (error) {
       const msg = parseErrorMessage(error);
@@ -10275,4 +10547,4 @@ export {
   loadConveyorConfig,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-B4QHEMMV.js.map
+//# sourceMappingURL=chunk-WZCO64YR.js.map