@rallycry/conveyor-agent 8.11.0 → 8.13.0

package/dist/{chunk-IB6M4OVT.js → chunk-L7Q2JZJX.js}

@@ -177,18 +177,72 @@ var AgentConnection = class _AgentConnection {
     return this.socket?.connected ?? false;
   }
   // ── Typed service method call ──────────────────────────────────────────
-  call(method, payload) {
-    if (!this.socket) {
-      return Promise.reject(
-        new Error(`Not connected (method: ${String(method)}, session: ${this.config.sessionId})`)
+  // Socket.IO keeps the SAME Socket instance across transport-level
+  // reconnects (it only goes null on an explicit disconnect() teardown), so a
+  // brief flap leaves `this.socket` non-null but `.connected === false`. Rather
+  // than failing a tool call instantly (which the spawned `claude` surfaces as
+  // "Conveyor MCP disconnected" and an excuse to go idle), we wait out a short
+  // reconnect window, then emit with an ack timeout so a buffered packet whose
+  // ack never returns can't hang the call forever. We do NOT auto-retry the
+  // emit — re-sending a write could double-apply it; the agent prompt instructs
+  // the model to retry the tool, which is the safe place to decide idempotency.
+  static CALL_CONNECT_WAIT_MS = 2e4;
+  static CALL_ACK_TIMEOUT_MS = 3e4;
+  async call(method, payload) {
+    const socket = this.socket;
+    if (!socket) {
+      throw new Error(
+        `Not connected (method: ${String(method)}, session: ${this.config.sessionId})`
       );
     }
-    const socket = this.socket;
+    if (!socket.connected) {
+      await this.waitForConnected(socket, _AgentConnection.CALL_CONNECT_WAIT_MS, String(method));
+    }
+    return await this.emitWithAck(socket, method, payload);
+  }
+  /** Resolve once `socket` reports connected, or reject after `timeoutMs`. */
+  waitForConnected(socket, timeoutMs, method) {
+    if (socket.connected) return Promise.resolve();
     return new Promise((resolve2, reject) => {
+      const cleanup = () => {
+        clearTimeout(timer);
+        socket.off("connect", onConnect);
+      };
+      const onConnect = () => {
+        cleanup();
+        resolve2();
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(
+          new Error(
+            `Not connected \u2014 socket did not reconnect within ${timeoutMs / 1e3}s (method: ${method}, session: ${this.config.sessionId}). Transient; retry.`
+          )
+        );
+      }, timeoutMs);
+      socket.once("connect", onConnect);
+    });
+  }
+  /** Emit an RPC and resolve on ack, rejecting if no ack arrives in time. */
+  emitWithAck(socket, method, payload) {
+    return new Promise((resolve2, reject) => {
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        reject(
+          new Error(
+            `Service call timed out after ${_AgentConnection.CALL_ACK_TIMEOUT_MS / 1e3}s (method: ${String(method)}, session: ${this.config.sessionId}). Usually a transient reconnect; retry.`
+          )
+        );
+      }, _AgentConnection.CALL_ACK_TIMEOUT_MS);
       socket.emit(
         `agentSessionService:${String(method)}`,
         payload,
         (response) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
           if (response.success && response.data !== void 0) {
             resolve2(response.data);
           } else {
@@ -2315,10 +2369,12 @@ function buildPackRunnerSystemPrompt(context, config, setupLog) {
   }
   parts.push(
     ``,
-    `Your responses are sent directly to the task chat \u2014 the team sees everything you say.`,
-    `Do NOT call the post_to_chat tool for your own task; your replies already appear in chat automatically.`,
-    `Only use post_to_chat if you need to message a different task's chat (e.g. a child task).`,
-    `Use read_task_chat only if you need to re-read earlier messages beyond the chat context above.`
+    `Your turn output appears ONLY in the live agent terminal \u2014 it is NOT posted to the task chat. The team does NOT see your replies unless you post them.`,
+    `Use post_to_chat (omit task_id \u2192 this task's chat) to report which children you fired, status as you orchestrate, and any blocker or escalation the team needs to act on.`,
+    `Pass task_id only to message a DIFFERENT task's chat (e.g. a child task).`,
+    `Use read_task_chat only if you need to re-read earlier messages beyond the chat context above.`,
+    ``,
+    `If a Conveyor tool call fails or reports the MCP server is unavailable/disconnected, this is almost always a transient socket reconnect \u2014 RETRY the same call; it will succeed once the connection re-establishes. A tool error is NOT a reason to go idle or stop the loop. (Going idle is only correct when you are genuinely waiting on child-task status changes or CI \u2014 see the loop above.)`
   );
   return parts.join("\n");
 }
@@ -3028,7 +3084,7 @@ Environment (ready, no setup required):`,
 Workflow:`,
     `- 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_plan directly to save the plan to the task.`,
-    `- After saving the plan, end your turn with a summary reply (the team sees your responses in chat automatically). Do NOT attempt to execute the plan yourself.`,
+    `- After saving the plan, call post_to_chat with a short summary for the team (your turn output is NOT posted to chat \u2014 they only see what you post), then 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.`
   ];
   if (context.isParentTask) {
@@ -3160,10 +3216,12 @@ ${config.instructions}`);
   }
   parts.push(
     `
-Your responses are sent directly to the task chat \u2014 the team sees everything you say.`,
-    `Do NOT call the post_to_chat tool for your own task; your replies already appear in chat automatically.`,
-    `Only use post_to_chat if you need to message a different task's chat (e.g. a parent task via get_task).`,
-    `Use read_task_chat only if you need to re-read earlier messages beyond the chat context above.`
+Your turn output appears ONLY in the live agent terminal \u2014 it is NOT posted to the task chat. The team does NOT see your replies unless you post them.`,
+    `Use post_to_chat (omit task_id \u2192 your own task's chat) to share meaningful status as you work, a summary when you finish, and any blocker or question you need a human to answer.`,
+    `Pass task_id only to message a DIFFERENT task's chat (e.g. a parent task via get_task).`,
+    `Use read_task_chat only if you need to re-read earlier messages beyond the chat context above.`,
+    `
+If a Conveyor tool call fails or reports the MCP server is unavailable/disconnected, this is almost always a transient socket reconnect \u2014 simply RETRY the same call and it will succeed once the connection re-establishes. Do NOT stop work, go idle, or treat a tool error as a reason to end your turn. Keep making progress on the code; only post_to_chat to ask for a human if a tool keeps failing across several retries over a sustained period.`
   );
   if (!isPm || isPmActive) {
     parts.push(
@@ -3302,7 +3360,7 @@ Address the requested changes. Do NOT re-investigate the codebase from scratch o
       );
     } else {
       parts.push(
-        `Reply with a brief status update (visible in chat), then wait for further instructions.`
+        `Post a brief status update with post_to_chat (your turn output is NOT shown in chat \u2014 post_to_chat is how the team sees it), then wait for further instructions.`
       );
     }
     if (context.githubPRUrl) {
@@ -3411,7 +3469,7 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
       `Review existing subtasks via \`list_subtasks\` and the chat history before taking action.`,
       `Read the task description and chat history carefully \u2014 the team has provided the initial context below. Acknowledge what they've asked for and respond in chat before taking silent tool actions.`,
       `Start planning now \u2014 explore the codebase, ask clarifying questions if needed, and propose a subtask breakdown. Do not wait for additional team input before engaging.`,
-      `When you finish planning, save the plan with update_task_plan and end your turn. Your reply will be visible to the team in chat.`
+      `When you finish planning, save the plan with update_task_plan, post a short summary for the team with post_to_chat (your turn output is NOT shown in chat), then end your turn.`
     ];
   }
   if (isPm) {
@@ -3419,14 +3477,14 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
       `You are the project manager for this task.`,
       `Read the task description and chat history carefully \u2014 the team has provided the initial context below. Acknowledge what they've asked for and respond in chat before taking silent tool actions.`,
       `Start planning now \u2014 explore the codebase, ask clarifying questions if needed, and draft a plan. Do not wait for additional team input before engaging; the initial message IS the team engaging.`,
-      `When you finish planning, save the plan with update_task_plan and end your turn. Your reply summarizing the plan will be visible in chat. A separate task agent will execute the plan after review.`
+      `When you finish planning, save the plan with update_task_plan, post a summary of the plan for the team with post_to_chat (your turn output is NOT shown in chat), then end your turn. A separate task agent will execute the plan after review.`
     ];
   }
   const parts = [
     `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}". Stay on this branch for the entire task. Do not checkout or create other branches.`,
-    `Your replies are visible to the team in chat \u2014 briefly describe what you're doing when you begin meaningful implementation, and again when the PR is ready.`,
+    `Use post_to_chat to keep the team informed (your turn output is NOT shown in chat \u2014 post_to_chat is the only way they see it): briefly post what you're doing when you begin meaningful implementation, and again when the PR is ready.`,
     `Before opening the PR, run the quality gates: \`bun run lint && bun run typecheck && bun run test\`. Fix any failures. Do NOT open a PR with known failing gates \u2014 scope the test run to affected packages if the full suite is prohibitively slow, and state the scope in the PR body.`,
     `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
   ];
@@ -3533,7 +3591,7 @@ function buildIdleRelaunchInstructions(context, isPm, agentMode, isAuto) {
     );
   } else {
     parts.push(
-      `Reply with a brief status update summarizing where things stand (visible in chat).`,
+      `Post a brief status update summarizing where things stand with post_to_chat (your turn output is NOT shown in chat \u2014 post_to_chat is how the team sees it).`,
       `Then wait for further instructions \u2014 do NOT redo work that was already completed.`
     );
   }
@@ -3805,7 +3863,7 @@ import { z as z6 } from "zod";
 function buildPostToChatTool(connection) {
   return defineTool(
     "post_to_chat",
-    "Post an out-of-band chat message to a task. Use only when explicitly asked, or to message a child's chat (pass its ID). Normal replies already appear in chat automatically.",
+    "Post a message to the task chat for the team to see. Your turn output is NOT shown in chat, so this is the only way the team sees your status, summaries, and questions. Omit task_id to post to the current task's chat; pass a child's ID to message its chat.",
     {
       message: z6.string().describe("The message to post to the team"),
       task_id: z6.string().optional().describe("Child task ID to post to. Omit to post to the current task's chat.")
@@ -7063,6 +7121,18 @@ function latestUserMessageText(context) {
   }
   return null;
 }
+function selectInitialPromptInput(promptDelivery, initialPrompt, context, baseAppendSystemPrompt) {
+  if (promptDelivery === "prefill") {
+    return {
+      prompt: latestUserMessageText(context) ?? "",
+      appendSystemPrompt: [baseAppendSystemPrompt, initialPrompt].filter(Boolean).join("\n\n").slice(0, APPEND_SYSTEM_PROMPT_MAX_CHARS)
+    };
+  }
+  return {
+    prompt: buildMultimodalPrompt(initialPrompt, context),
+    appendSystemPrompt: baseAppendSystemPrompt
+  };
+}
 async function runInitialQuery(host, context, options, resume, promptDelivery) {
   const initialPrompt = await buildInitialPrompt(
     host.config.mode,
@@ -7070,15 +7140,13 @@ async function runInitialQuery(host, context, options, resume, promptDelivery) {
     host.isAuto,
     host.agentMode
   );
-  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);
-  }
+  const { prompt, appendSystemPrompt } = selectInitialPromptInput(
+    promptDelivery,
+    initialPrompt,
+    context,
+    options.appendSystemPrompt
+  );
+  const queryOptions = { ...options, appendSystemPrompt };
   let agentQuery = host.harness.executeQuery({
     prompt: host.createInputStream(prompt),
     options: queryOptions,
@@ -8078,6 +8146,7 @@ var SessionRunner = class _SessionRunner {
     if (msg.delivery !== "prefill") return false;
     if (this.pendingMessages.length > 0) return false;
     if (this.queryBridge?.harnessKind !== "pty") return false;
+    if (this.mode.isAuto) 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";
@@ -9599,7 +9668,7 @@ function buildPostToChatTool2(connection, getRequestingUserId) {
   const projectId = connection.projectId;
   return defineTool(
     "post_to_chat",
-    "Post an out-of-band message into a chat. Omit task_id to post into the project chat; pass task_id to post into a specific task's chat. Normal replies already appear in chat automatically.",
+    "Post a message into a chat for the team to see. Your turn output is NOT shown in chat, so this is the only way the team sees your status, summaries, and questions. Omit task_id to post into the project chat; pass task_id to post into a specific task's chat.",
     {
       message: z17.string().describe("The message content to post"),
       task_id: z17.string().optional().describe("Task ID to post into a specific task's chat. Omit for the project chat.")
@@ -10802,4 +10871,4 @@ export {
   loadConveyorConfig,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-IB6M4OVT.js.map
+//# sourceMappingURL=chunk-L7Q2JZJX.js.map