@rallycry/conveyor-agent 5.7.0 → 5.9.0

package/dist/{chunk-LYXKPBQN.js → chunk-TYRSIHW2.js}

@@ -688,7 +688,7 @@ function errorMeta(error) {
 import { randomUUID as randomUUID2 } from "crypto";
 import { execSync as execSync4 } from "child_process";
 
-// src/execution/event-processor.ts
+// src/execution/event-handlers.ts
 function epochSecondsToISO(value) {
   if (typeof value === "string") return value;
   if (typeof value !== "number" || value <= 0) return void 0;
@@ -887,114 +887,138 @@ async function handleSystemEvent(event, host, context, sessionIdStored) {
   });
   return !!(event.session_id && !sessionIdStored);
 }
+function handleSystemSubevents(systemEvent, host) {
+  if (systemEvent.subtype === "compact_boundary") {
+    void host.callbacks.onEvent({
+      type: "context_compacted",
+      trigger: systemEvent.compact_metadata.trigger,
+      preTokens: systemEvent.compact_metadata.pre_tokens
+    });
+  } else if (systemEvent.subtype === "task_started") {
+    void host.callbacks.onEvent({
+      type: "subagent_started",
+      sdkTaskId: systemEvent.task_id,
+      description: systemEvent.description
+    });
+  } else if (systemEvent.subtype === "task_progress") {
+    void host.callbacks.onEvent({
+      type: "subagent_progress",
+      sdkTaskId: systemEvent.task_id,
+      description: systemEvent.description,
+      toolUses: systemEvent.usage?.tool_uses ?? 0,
+      durationMs: systemEvent.usage?.duration_ms ?? 0
+    });
+  }
+}
+function handleToolProgressEvent(event, host) {
+  const msg = event;
+  void host.callbacks.onEvent({
+    type: "tool_progress",
+    toolName: msg.tool_name ?? "",
+    elapsedSeconds: msg.elapsed_time_seconds ?? 0
+  });
+}
+async function handleAssistantCase(event, host, turnToolCalls) {
+  await processAssistantEvent(event, host, turnToolCalls);
+  const msgUsage = event.message.usage;
+  return msgUsage ?? void 0;
+}
+async function handleResultCase(event, host, context, startTime, isTyping, lastAssistantUsage) {
+  let stoppedTyping = false;
+  if (isTyping) {
+    host.connection.sendTypingStop();
+    stoppedTyping = true;
+  }
+  const resultInfo = await emitResultEvent(event, host, context, startTime, lastAssistantUsage);
+  return {
+    retriable: resultInfo.retriable,
+    resultSummary: resultInfo.resultSummary,
+    staleSession: resultInfo.staleSession,
+    stoppedTyping
+  };
+}
+
+// src/execution/event-processor.ts
+function stopTypingIfNeeded(host, isTyping) {
+  if (isTyping) host.connection.sendTypingStop();
+}
+async function processSystemCase(event, host, context, state) {
+  if (event.subtype === "init") {
+    const stored = await handleSystemEvent(event, host, context, state.sessionIdStored);
+    if (stored) state.sessionIdStored = true;
+  } else {
+    handleSystemSubevents(
+      event,
+      host
+    );
+  }
+}
+async function processAssistantCase(event, host, state) {
+  if (!state.isTyping) {
+    setTimeout(() => host.connection.sendTypingStart(), 200);
+    state.isTyping = true;
+  }
+  const usage = await handleAssistantCase(event, host, state.turnToolCalls);
+  if (usage) state.lastAssistantUsage = usage;
+}
+async function processResultCase(event, host, context, startTime, state) {
+  const info = await handleResultCase(
+    event,
+    host,
+    context,
+    startTime,
+    state.isTyping,
+    state.lastAssistantUsage
+  );
+  if (info.stoppedTyping) state.isTyping = false;
+  state.retriable = info.retriable;
+  state.resultSummary = info.resultSummary;
+  if (info.staleSession) state.staleSession = true;
+}
 async function processEvents(events, context, host) {
   const startTime = Date.now();
-  let sessionIdStored = false;
-  let isTyping = false;
-  let retriable = false;
-  let resultSummary;
-  let rateLimitResetsAt;
-  let staleSession;
-  let lastAssistantUsage;
-  const turnToolCalls = [];
+  const state = {
+    sessionIdStored: false,
+    isTyping: false,
+    retriable: false,
+    resultSummary: void 0,
+    rateLimitResetsAt: void 0,
+    staleSession: void 0,
+    lastAssistantUsage: void 0,
+    turnToolCalls: []
+  };
   for await (const event of events) {
     if (host.isStopped()) break;
     if (host.pendingModeRestart) {
-      if (isTyping) {
-        host.connection.sendTypingStop();
-      }
+      stopTypingIfNeeded(host, state.isTyping);
       return { retriable: false, modeRestart: true };
     }
     switch (event.type) {
-      case "system": {
-        const systemEvent = event;
-        if (systemEvent.subtype === "init") {
-          const stored = await handleSystemEvent(systemEvent, host, context, sessionIdStored);
-          if (stored) sessionIdStored = true;
-        } else if (systemEvent.subtype === "compact_boundary") {
-          const meta = systemEvent.compact_metadata;
-          if (meta) {
-            void host.callbacks.onEvent({
-              type: "context_compacted",
-              trigger: meta.trigger,
-              preTokens: meta.pre_tokens
-            });
-          }
-        } else if (systemEvent.subtype === "task_started") {
-          const msg = systemEvent;
-          void host.callbacks.onEvent({
-            type: "subagent_started",
-            sdkTaskId: msg.task_id ?? "",
-            description: msg.description ?? ""
-          });
-        } else if (systemEvent.subtype === "task_progress") {
-          const msg = systemEvent;
-          void host.callbacks.onEvent({
-            type: "subagent_progress",
-            sdkTaskId: msg.task_id ?? "",
-            description: msg.description ?? "",
-            toolUses: msg.usage?.tool_uses ?? 0,
-            durationMs: msg.usage?.duration_ms ?? 0
-          });
-        }
+      case "system":
+        await processSystemCase(event, host, context, state);
         break;
-      }
-      case "assistant": {
-        if (!isTyping) {
-          setTimeout(() => host.connection.sendTypingStart(), 200);
-          isTyping = true;
-        }
-        const assistantEvent = event;
-        await processAssistantEvent(assistantEvent, host, turnToolCalls);
-        const msgUsage = assistantEvent.message.usage;
-        if (msgUsage) {
-          lastAssistantUsage = msgUsage;
-        }
+      case "assistant":
+        await processAssistantCase(event, host, state);
         break;
-      }
-      case "result": {
-        if (isTyping) {
-          host.connection.sendTypingStop();
-          isTyping = false;
-        }
-        const resultInfo = await emitResultEvent(
-          event,
-          host,
-          context,
-          startTime,
-          lastAssistantUsage
-        );
-        retriable = resultInfo.retriable;
-        resultSummary = resultInfo.resultSummary;
-        if (resultInfo.staleSession) {
-          staleSession = true;
-        }
+      case "result":
+        await processResultCase(event, host, context, startTime, state);
         break;
-      }
       case "rate_limit_event": {
         const resetsAt = handleRateLimitEvent(event, host);
-        if (resetsAt) rateLimitResetsAt = resetsAt;
+        if (resetsAt) state.rateLimitResetsAt = resetsAt;
         break;
       }
-      case "tool_progress": {
-        const msg = event;
-        void host.callbacks.onEvent({
-          type: "tool_progress",
-          toolName: msg.tool_name ?? "",
-          elapsedSeconds: msg.elapsed_time_seconds ?? 0
-        });
+      case "tool_progress":
+        handleToolProgressEvent(event, host);
         break;
-      }
     }
   }
-  if (isTyping) {
-    host.connection.sendTypingStop();
-  }
+  stopTypingIfNeeded(host, state.isTyping);
   return {
-    retriable,
-    resultSummary,
-    rateLimitResetsAt,
-    ...staleSession && { staleSession }
+    retriable: state.retriable,
+    resultSummary: state.resultSummary,
+    rateLimitResetsAt: state.rateLimitResetsAt,
+    ...state.staleSession && { staleSession: state.staleSession }
   };
 }
 
@@ -1666,7 +1690,7 @@ function buildInstructions(mode, context, scenario, agentMode) {
     return parts;
   }
   if (scenario === "idle_relaunch") {
-    if (isPm && (agentMode === "building" || agentMode === "review")) {
+    if (isPm && (agentMode === "building" || agentMode === "review" || agentMode === "auto")) {
       parts.push(
         `You were relaunched but no new instructions have been given since your last run.`,
         `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
@@ -2086,27 +2110,27 @@ function buildSubtaskTools(connection, spDescription) {
     )
   ];
 }
+function buildUpdateTaskTool(connection) {
+  return tool2(
+    "update_task",
+    "Save the finalized task plan and/or description",
+    {
+      plan: z2.string().optional().describe("The task plan in markdown"),
+      description: z2.string().optional().describe("Updated task description")
+    },
+    async ({ plan, description }) => {
+      try {
+        await Promise.resolve(connection.updateTaskFields({ plan, description }));
+        return textResult("Task updated successfully.");
+      } catch {
+        return textResult("Failed to update task.");
+      }
+    }
+  );
+}
 function buildPmTools(connection, storyPoints, options) {
   const spDescription = buildStoryPointDescription(storyPoints);
-  const tools = [
-    tool2(
-      "update_task",
-      "Save the finalized task plan and/or description",
-      {
-        plan: z2.string().optional().describe("The task plan in markdown"),
-        description: z2.string().optional().describe("Updated task description")
-      },
-      async ({ plan, description }) => {
-        try {
-          await Promise.resolve(connection.updateTaskFields({ plan, description }));
-          return textResult("Task updated successfully.");
-        } catch {
-          return textResult("Failed to update task.");
-        }
-      }
-    ),
-    ...buildSubtaskTools(connection, spDescription)
-  ];
+  const tools = [buildUpdateTaskTool(connection), ...buildSubtaskTools(connection, spDescription)];
   if (!options?.includePackTools) return tools;
   return [...tools, ...buildPackTools(connection)];
 }
@@ -2296,7 +2320,14 @@ function textResult(text) {
 function imageBlock(data, mimeType) {
   return { type: "image", data, mimeType };
 }
+function getTaskModeTools(agentMode, connection) {
+  if (agentMode === "discovery" || agentMode === "auto") {
+    return [buildUpdateTaskTool(connection)];
+  }
+  return [];
+}
 function getModeTools(agentMode, connection, config, context) {
+  if (config.mode === "task") return getTaskModeTools(agentMode, connection);
   switch (agentMode) {
     case "building":
       return context?.isParentTask ? buildPmTools(connection, context?.storyPoints, { includePackTools: true }) : [];
@@ -2392,6 +2423,7 @@ function handleAutoToolAccess(toolName, input, hasExitedPlanMode, isParentTask)
 }
 async function handleExitPlanMode(host, input) {
   try {
+    host.syncPlanFile();
     const taskProps = await host.connection.getTaskProperties();
     const missingProps = [];
     if (!taskProps.plan?.trim()) missingProps.push("plan (save via update_task)");
@@ -2636,7 +2668,8 @@ async function runSdkQuery(host, context, followUpContent) {
   if (host.isStopped()) return;
   const mode = host.agentMode;
   const isDiscoveryLike = mode === "discovery" || mode === "help";
-  if (isDiscoveryLike) {
+  const needsPlanSync = isDiscoveryLike || mode === "auto" && !host.hasExitedPlanMode;
+  if (needsPlanSync) {
     host.snapshotPlanFiles();
   }
   const options = buildQueryOptions(host, context);
@@ -2669,7 +2702,7 @@ async function runSdkQuery(host, context, followUpContent) {
       host.activeQuery = null;
     }
   }
-  if (isDiscoveryLike) {
+  if (needsPlanSync) {
     host.syncPlanFile();
   }
 }
@@ -2927,6 +2960,7 @@ async function executeSetupConfig(config, runnerConfig, connection, setupLog) {
     pushSetupLog(setupLog, `$ ${config.setupCommand}`);
     await runSetupCommand(config.setupCommand, runnerConfig.workspaceDir, (stream, data) => {
       connection.sendEvent({ type: "setup_output", stream, data });
+      (stream === "stderr" ? process.stderr : process.stdout).write(data);
       for (const line of data.split("\n").filter(Boolean)) {
         pushSetupLog(setupLog, `[${stream}] ${line}`);
       }
@@ -2937,6 +2971,7 @@ async function executeSetupConfig(config, runnerConfig, connection, setupLog) {
     pushSetupLog(setupLog, `$ ${config.startCommand} &  (background)`);
     runStartCommand(config.startCommand, runnerConfig.workspaceDir, (stream, data) => {
       connection.sendEvent({ type: "start_command_output", stream, data });
+      (stream === "stderr" ? process.stderr : process.stdout).write(data);
     });
   }
 }
@@ -3030,6 +3065,7 @@ function rerunStartCommand(conveyorConfig, runnerConfig, connection, setupLog) {
   connection.sendEvent({ type: "start_command_started" });
   runStartCommand(conveyorConfig.startCommand, runnerConfig.workspaceDir, (stream, data) => {
     connection.sendEvent({ type: "start_command_output", stream, data });
+    (stream === "stderr" ? process.stderr : process.stdout).write(data);
   });
   const setupEvent = {
     type: "setup_complete",
@@ -3233,7 +3269,7 @@ var AgentRunner = class {
     await this.setState("connected");
     this.connection.sendEvent({ type: "connected", taskId: this.config.taskId });
     this.startHeartbeat();
-    if (this.config.mode !== "pm" && process.env.CODESPACES === "true") {
+    if (process.env.CODESPACES === "true") {
       const result = await runSetupSafe(
         this.config,
         this.connection,
@@ -4079,4 +4115,4 @@ export {
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-LYXKPBQN.js.map
+//# sourceMappingURL=chunk-TYRSIHW2.js.map