meshy-node 0.10.7 → 0.10.9

package/main.cjs

@@ -136339,6 +136339,8 @@ var fs3 = __toESM(require("fs"), 1);
 var os3 = __toESM(require("os"), 1);
 var path3 = __toESM(require("path"), 1);
 var STARTUP_TRANSPORTS = /* @__PURE__ */ new Set(["direct", "devtunnel", "tailscale"]);
+var DEFAULT_TASK_AGENTS = /* @__PURE__ */ new Set(["codex", "claudecode", "copilot"]);
+var DEFAULT_NODE_TASK_AGENT = "codex";
 function getDeviceNodeName() {
   return os3.hostname();
 }
@@ -136408,6 +136410,9 @@ function normalizeString(value) {
 function normalizeStartupTransport(value) {
   return typeof value === "string" && STARTUP_TRANSPORTS.has(value) ? value : void 0;
 }
+function normalizeDefaultTaskAgent(value) {
+  return typeof value === "string" && DEFAULT_TASK_AGENTS.has(value) ? value : void 0;
+}
 function normalizeStartupMetadata(startup) {
   return {
     port: normalizePositiveInteger(startup?.port),
@@ -136445,6 +136450,9 @@ function resolveDefaultNodeName(storagePath, deviceName = getDeviceNodeName()) {
   const preferredName = resolvePersistedDefaultNodeName(storagePath);
   return preferredName && preferredName.length > 0 ? preferredName : deviceName;
 }
+function resolveNodeDefaultTaskAgent(storagePath) {
+  return normalizeDefaultTaskAgent(readNodeMetadata(storagePath).defaultTaskAgent) ?? DEFAULT_NODE_TASK_AGENT;
+}
 function persistDefaultNodeName(storagePath, name2, deviceName = getDeviceNodeName()) {
   const metadata = readNodeMetadata(storagePath);
   const normalizedName = name2.trim();
@@ -136455,6 +136463,11 @@ function persistDefaultNodeName(storagePath, name2, deviceName = getDeviceNodeNa
   }
   writeNodeMetadata(storagePath, metadata);
 }
+function persistNodeDefaultTaskAgent(storagePath, agent) {
+  const metadata = readNodeMetadata(storagePath);
+  metadata.defaultTaskAgent = agent;
+  writeNodeMetadata(storagePath, metadata);
+}
 function resolveNodeAuthMetadata(storagePath) {
   return normalizeAuthMetadata(readNodeMetadata(storagePath).auth);
 }
@@ -136958,6 +136971,7 @@ function parseTaskQueuedMessages(value) {
     messages.push({
       id: entry.id,
       content: clone(entry.content),
+      ...typeof entry.targetAgent === "string" ? { targetAgent: entry.targetAgent } : {},
       createdAt: entry.createdAt
     });
   }
@@ -138439,7 +138453,7 @@ var TaskEngine = class {
     });
     return true;
   }
-  enqueueTaskMessage(taskId, content3) {
+  enqueueTaskMessage(taskId, content3, targetAgent) {
     const task = this.store.getTask(taskId);
     if (!task) {
       throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
@@ -138454,7 +138468,12 @@ var TaskEngine = class {
     const now = Date.now();
     const queuedMessages = [
       ...task.queuedMessages ?? [],
-      { id: (0, import_node_crypto5.randomUUID)(), content: content3, createdAt: now }
+      {
+        id: (0, import_node_crypto5.randomUUID)(),
+        content: content3,
+        ...targetAgent ? { targetAgent } : {},
+        createdAt: now
+      }
     ];
     const updated = this.store.updateTask(taskId, { queuedMessages, updatedAt: now });
     this.eventBus.emit("task.updated", {
@@ -138742,11 +138761,12 @@ var DEFAULT_CONFIG = {
   dispatchTimeout: 1e4
 };
 var TaskDispatcher = class {
-  constructor(taskEngine, nodeRegistry, election, eventBus, config2, logger33, nodeMessageClient) {
+  constructor(taskEngine, nodeRegistry, election, eventBus, config2, logger33, nodeMessageClient, localNodeMessageHandler) {
     this.taskEngine = taskEngine;
     this.nodeRegistry = nodeRegistry;
     this.election = election;
     this.eventBus = eventBus;
+    this.localNodeMessageHandler = localNodeMessageHandler;
     this.config = { ...DEFAULT_CONFIG, ...config2 };
     this.log = logger33?.child("task-dispatcher") ?? { debug() {
     }, info() {
@@ -138756,10 +138776,7 @@ var TaskDispatcher = class {
       return this;
     } };
     this.messageClient = nodeMessageClient ?? new NodeMessageClient({ timeoutMs: this.config.dispatchTimeout, logger: logger33 });
-    this.onTaskAssigned = (data) => {
-      void this.dispatchTask(data.taskId, data.nodeId).catch(() => {
-      });
-    };
+    this.onTaskAssigned = (data) => this.scheduleDispatch(data.taskId, data.nodeId);
     this.onElectionComplete = (data) => {
       const self2 = this.nodeRegistry.getSelf();
       if (data.leaderId === self2.id) {
@@ -138773,10 +138790,12 @@ var TaskDispatcher = class {
   nodeRegistry;
   election;
   eventBus;
+  localNodeMessageHandler;
   config;
   log;
   messageClient;
   autoAssignTimer = null;
+  pendingDispatchTimers = /* @__PURE__ */ new Set();
   running = false;
   onTaskAssigned;
   onElectionComplete;
@@ -138794,6 +138813,7 @@ var TaskDispatcher = class {
     this.eventBus.off("task.assigned", this.onTaskAssigned);
     this.eventBus.off("election.complete", this.onElectionComplete);
     this.stopAutoAssignLoop();
+    this.clearPendingDispatchTimers();
   }
   // ── Dispatch ────────────────────────────────────────────────────────
   async dispatchTask(taskId, nodeId) {
@@ -138817,7 +138837,13 @@ var TaskDispatcher = class {
         endpoint: node2.endpoint,
         devtunnelEndpoint: node2.devtunnelEndpoint
       });
-      await this.messageClient.send(node2, createNodeMessage("task.execute", { task }));
+      const message = createNodeMessage("task.execute", { task });
+      if (node2.id === this.nodeRegistry.getSelf().id && this.localNodeMessageHandler) {
+        await this.localNodeMessageHandler(message);
+        this.log.info("task dispatch request accepted", { taskId, nodeId, local: true });
+        return;
+      }
+      await this.messageClient.send(node2, message);
       this.log.info("task dispatch request accepted", { taskId, nodeId });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -138843,6 +138869,20 @@ var TaskDispatcher = class {
       this.autoAssignTimer = null;
     }
   }
+  scheduleDispatch(taskId, nodeId) {
+    const timer = setTimeout(() => {
+      this.pendingDispatchTimers.delete(timer);
+      void this.dispatchTask(taskId, nodeId).catch(() => {
+      });
+    }, 0);
+    this.pendingDispatchTimers.add(timer);
+  }
+  clearPendingDispatchTimers() {
+    for (const timer of this.pendingDispatchTimers) {
+      clearTimeout(timer);
+    }
+    this.pendingDispatchTimers.clear();
+  }
 };
 
 // ../../packages/core/src/cluster/heartbeat.ts
@@ -140021,6 +140061,31 @@ var ExecutionEngine = class {
       await Promise.all([...this.logWrites.values()]);
     }
   }
+  async getLogLineCount(taskId) {
+    const logPath = this.getLogPath(taskId);
+    try {
+      const content3 = await fs7.promises.readFile(logPath, "utf-8");
+      const trimmed = content3.trim();
+      return trimmed ? trimmed.split("\n").filter(Boolean).length : 0;
+    } catch (error2) {
+      if (error2.code === "ENOENT") return 0;
+      throw error2;
+    }
+  }
+  async flushLogsAndEmitReady(taskId) {
+    try {
+      await this.waitForLogWrites();
+      const total = await this.getLogLineCount(taskId);
+      this.eventBus.emit("task.logs.ready", { taskId, total });
+      return total;
+    } catch (error2) {
+      this.logger.warn("failed to emit task log readiness checkpoint", {
+        taskId,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      });
+      return 0;
+    }
+  }
   getLogPath(taskId) {
     return path7.join(this.logDir, `${taskId}.jsonl`);
   }
@@ -140886,9 +140951,59 @@ function nonEmptyString(value) {
 function getNativeHistorySessionId(payload) {
   return nonEmptyString(payload?.nativeSessionId) || nonEmptyString(payload?.sessionId);
 }
-function buildPersistedSessionPayload(task, sessionId, cwd) {
+function isRecord5(value) {
+  return typeof value === "object" && value !== null;
+}
+function getAgentSessions(payload) {
+  const raw3 = payload.agentSessions;
+  if (!isRecord5(raw3)) return {};
+  const sessions = {};
+  for (const [agent, value] of Object.entries(raw3)) {
+    if (!isRecord5(value)) continue;
+    const sessionId = nonEmptyString(value.sessionId);
+    const cwd = nonEmptyString(value.cwd);
+    if (!agent || !sessionId || !cwd) continue;
+    sessions[agent] = { sessionId, cwd };
+  }
+  return sessions;
+}
+function getPersistedAgentSession(task, agent) {
+  const payload = task?.payload ?? {};
+  const sessions = getAgentSessions(payload);
+  const session = sessions[agent];
+  if (session) return session;
+  if (Object.keys(sessions).length > 0 || task?.agent !== agent) {
+    return null;
+  }
+  const legacySessionId = nonEmptyString(payload.sessionId);
+  if (!legacySessionId) return null;
+  return {
+    sessionId: legacySessionId,
+    cwd: nonEmptyString(payload.sessionCwd)
+  };
+}
+function canUseSessionLogEventForAgent(task, agent, event) {
+  const eventAgent = nonEmptyString(event.agent);
+  if (eventAgent) return eventAgent === agent;
+  const sessions = getAgentSessions(task?.payload ?? {});
+  return Object.keys(sessions).length === 0 && task?.agent === agent;
+}
+function buildPersistedSessionPayload(task, sessionId, cwd, agent) {
   const payload = task?.payload ?? {};
+  const activeAgent = nonEmptyString(agent);
   const nextPayload = { ...payload, sessionId, sessionCwd: cwd };
+  if (activeAgent) {
+    const agentSessions = getAgentSessions(payload);
+    const taskAgent = nonEmptyString(task?.agent);
+    const legacySessionId = nonEmptyString(payload.sessionId);
+    const legacyCwd = nonEmptyString(payload.sessionCwd) || cwd;
+    if (taskAgent && legacySessionId && !agentSessions[taskAgent]) {
+      agentSessions[taskAgent] = { sessionId: legacySessionId, cwd: legacyCwd };
+    }
+    agentSessions[activeAgent] = { sessionId, cwd };
+    nextPayload.activeAgent = activeAgent;
+    nextPayload.agentSessions = agentSessions;
+  }
   if (task?.conversationKind !== "nativeSession") {
     return nextPayload;
   }
@@ -141001,10 +141116,44 @@ function forwardTaskOutputToLeader(log2, nodeRegistry, taskId, event) {
     });
   });
 }
+function postLogsReadyToLeader(log2, leaderEndpoint, taskId, total) {
+  fetch(`${leaderEndpoint}/api/worker/logs-ready`, applyRequestAuthHeaders({
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ taskId, total })
+  })).then((response) => {
+    if (!response.ok) {
+      log2.warn("leader rejected log readiness report", {
+        taskId,
+        total,
+        leaderEndpoint,
+        statusCode: response.status
+      });
+      return;
+    }
+    log2.debug("forwarded log readiness to leader", { taskId, total, leaderEndpoint, statusCode: response.status });
+  }).catch((err) => {
+    log2.warn("failed to forward log readiness", {
+      taskId,
+      total,
+      leaderEndpoint,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  });
+}
+function forwardTaskLogsReadyToLeader(log2, nodeRegistry, taskId, total) {
+  const leaderEndpoint = nodeRegistry.getLeaderEndpoint();
+  if (!leaderEndpoint) {
+    log2.warn("skipping log readiness forward because leader endpoint is missing", { taskId, total });
+    return;
+  }
+  postLogsReadyToLeader(log2, leaderEndpoint, taskId, total);
+}
 function registerLeaderForwarding(eventBus, nodeRegistry, log2, taskId, agent, reporter) {
   const cleanup = () => {
     eventBus.off("task.status", onTaskStatus);
     eventBus.off("task.output", onTaskOutput);
+    eventBus.off("task.logs.ready", onTaskLogsReady);
   };
   const onTaskOutput = (data) => {
     if (data.taskId !== taskId) return;
@@ -141016,6 +141165,16 @@ function registerLeaderForwarding(eventBus, nodeRegistry, log2, taskId, agent, r
     if (reporter) reporter.reportOutput(taskId, data.event);
     else forwardTaskOutputToLeader(log2, nodeRegistry, taskId, data.event);
   };
+  const onTaskLogsReady = (data) => {
+    if (data.taskId !== taskId) return;
+    log2.debug("task.logs.ready event", {
+      taskId,
+      total: data.total,
+      hasLeader: !!nodeRegistry.getLeaderEndpoint()
+    });
+    if (reporter) reporter.reportLogsReady(taskId, data.total);
+    else forwardTaskLogsReadyToLeader(log2, nodeRegistry, taskId, data.total);
+  };
   const onTaskStatus = (data) => {
     if (data.taskId !== taskId || data.status === "running") return;
     cleanup();
@@ -141041,11 +141200,175 @@ function registerLeaderForwarding(eventBus, nodeRegistry, log2, taskId, agent, r
     });
   };
   eventBus.on("task.output", onTaskOutput);
+  eventBus.on("task.logs.ready", onTaskLogsReady);
   eventBus.on("task.status", onTaskStatus);
   log2.debug("registered leader forwarding listeners", { taskId, agent });
   return cleanup;
 }
 
+// ../../packages/core/src/tasks/agent-task-turn.ts
+init_cjs_shims();
+function startAgentTaskTurn(options) {
+  const agent = resolveActiveAgent(options.task, options.targetAgent);
+  if (!supportsFollowUpAgent(agent)) {
+    throw new MeshyError("VALIDATION_ERROR", `Agent ${agent} does not support chat messages`, 400);
+  }
+  const engine = options.engineRegistry.get(agent);
+  if (!engine) {
+    throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${agent}`, 400);
+  }
+  const updates = {
+    status: "running",
+    assignedTo: options.assignedTo
+  };
+  if (options.targetAgent || options.task.payload.activeAgent !== void 0) {
+    updates.payload = {
+      ...options.task.payload,
+      activeAgent: agent
+    };
+  }
+  options.taskEngine.updateTask(options.task.id, updates);
+  const handoffEvent = buildExplicitHandoffEvent(options.task, options.targetAgent, agent);
+  if (handoffEvent) {
+    recordAndEmit(options, engine, handoffEvent);
+  }
+  const handoffContent = handoffEvent ? buildAgentHandoffContent(options.task, engine, options.content, agent) : null;
+  const sendContent = handoffContent ?? options.content;
+  const sendOptions = handoffContent ? { logContent: options.content } : void 0;
+  try {
+    if (sendOptions) engine.sendMessage(options.task.id, sendContent, sendOptions);
+    else engine.sendMessage(options.task.id, sendContent);
+    return;
+  } catch (err) {
+    if (!shouldStartHandoff(options.targetAgent, err)) {
+      throw err;
+    }
+    options.logger.info("starting cross-agent handoff turn", {
+      taskId: options.task.id,
+      fromAgent: resolveActiveAgent(options.task),
+      toAgent: agent,
+      ...options.metadata
+    });
+    startHandoffRun(options, engine, agent, !handoffEvent, handoffContent);
+  }
+}
+function resolveActiveAgent(task, targetAgent) {
+  const explicit = targetAgent?.trim();
+  if (explicit) return explicit;
+  const active = typeof task.payload.activeAgent === "string" ? task.payload.activeAgent.trim() : "";
+  return active || task.agent;
+}
+function shouldStartHandoff(targetAgent, err) {
+  return Boolean(targetAgent) && err instanceof MeshyError && err.code === "TASK_NOT_FOUND";
+}
+function buildExplicitHandoffEvent(task, targetAgent, agent) {
+  if (!targetAgent?.trim()) return null;
+  const fromAgent = resolveActiveAgent(task);
+  return fromAgent === agent ? null : buildAgentHandoffLogEvent(fromAgent, agent);
+}
+function startHandoffRun(options, engine, agent, recordBoundary, prebuiltContent) {
+  const fromAgent = resolveActiveAgent(options.task);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const boundary = buildAgentHandoffLogEvent(fromAgent, agent, timestamp);
+  const userEvent = {
+    ...buildTaskUserLogEvent(options.content, timestamp),
+    agent
+  };
+  if (recordBoundary) {
+    recordAndEmit(options, engine, boundary);
+  }
+  recordAndEmit(options, engine, userEvent);
+  const handoffTask = {
+    ...options.task,
+    agent,
+    status: "running",
+    assignedTo: options.assignedTo,
+    payload: {
+      ...options.task.payload,
+      activeAgent: agent,
+      initialMessage: prebuiltContent ?? buildAgentHandoffContent(options.task, engine, options.content, agent)
+    }
+  };
+  engine.run(handoffTask);
+}
+function recordAndEmit(options, engine, event) {
+  engine.recordOutput(options.task.id, event);
+  options.eventBus.emit("task.output", { taskId: options.task.id, event });
+}
+function buildAgentHandoffLogEvent(fromAgent, toAgent, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    type: "agent.handoff",
+    fromAgent,
+    toAgent,
+    timestamp
+  };
+}
+function buildAgentHandoffContent(task, engine, currentContent, targetAgent) {
+  const logs4 = readTaskLogs(engine, task.id);
+  const historyLines = extractVisibleTranscriptLines(logs4);
+  if (historyLines.length === 0) {
+    const initialLines = contentToVisibleLines("User", normalizeTaskUserMessageContent(task.payload.initialMessage));
+    historyLines.push(...initialLines);
+  }
+  const currentText = contentToPlainText(currentContent) || "[non-text user content]";
+  const text10 = [
+    `You are taking over this Meshy task as ${targetAgent}.`,
+    "",
+    "Previous visible conversation:",
+    historyLines.length > 0 ? historyLines.join("\n") : "[No visible previous transcript found.]",
+    "",
+    "Current user request:",
+    currentText
+  ].join("\n");
+  return [{ type: "text", text: text10 }, ...currentContent.filter((part) => part.type !== "text")];
+}
+function readTaskLogs(engine, taskId) {
+  return readJsonLines(engine.getLogPath(taskId));
+}
+function extractVisibleTranscriptLines(events) {
+  const lines = [];
+  for (const event of events) {
+    if (event.type === "user" && event.isMeta !== true && event.isSidechain !== true) {
+      lines.push(...contentToVisibleLines("User", extractUserContent(event)));
+    }
+    if (event.type === "assistant") {
+      const text10 = extractAssistantText(event);
+      if (text10) lines.push(`Assistant: ${text10}`);
+    }
+  }
+  return lines;
+}
+function extractUserContent(event) {
+  const message = isRecord6(event.message) ? event.message : null;
+  const messageContent = message?.content;
+  const directContent = event.content;
+  return normalizeTaskUserMessageContent(messageContent ?? directContent ?? event.message).filter((part) => part.type !== "tool_result");
+}
+function contentToVisibleLines(label, content3) {
+  const text10 = contentToPlainText(content3);
+  return text10 ? [`${label}: ${text10}`] : [];
+}
+function contentToPlainText(content3) {
+  return content3.map((part) => {
+    if (part.type === "text") return part.text;
+    if (part.type === "image") return `[image: ${part.filename ?? part.mediaType}]`;
+    return "";
+  }).filter(Boolean).join("\n").trim();
+}
+function extractAssistantText(event) {
+  if (typeof event.message === "string") return event.message.trim();
+  const content3 = isRecord6(event.message) ? event.message.content : event.content;
+  if (!Array.isArray(content3)) return "";
+  return content3.flatMap((block) => {
+    if (!isRecord6(block) || block.type !== "text" || typeof block.text !== "string") return [];
+    const text10 = block.text.trim();
+    return text10 ? [text10] : [];
+  }).join("\n").trim();
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null;
+}
+
 // ../../packages/core/src/tasks/leader-task-reporter.ts
 init_cjs_shims();
 var RestLeaderTaskReporter = class {
@@ -141089,6 +141412,14 @@ var RestLeaderTaskReporter = class {
       });
     });
   }
+  reportLogsReady(taskId, total) {
+    const leaderEndpoint = this.nodeRegistry.getLeaderEndpoint();
+    if (!leaderEndpoint) {
+      this.logger.warn("skipping log readiness report because leader endpoint is missing", { taskId, total });
+      return;
+    }
+    postLogsReadyToLeader(this.logger, leaderEndpoint, taskId, total);
+  }
   patchTask(taskId, data, label, successMessage) {
     const leaderEndpoint = this.nodeRegistry.getLeaderEndpoint();
     if (!leaderEndpoint) {
@@ -141540,14 +141871,14 @@ function getClaudeStreamError(event) {
   }
   return null;
 }
-function isRecord5(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null;
 }
 function getClaudeToolResultText(block) {
   const content3 = block.content;
   if (typeof content3 === "string") return content3;
   if (Array.isArray(content3)) {
-    return content3.filter(isRecord5).map((entry) => String(entry.text ?? "")).join("\n");
+    return content3.filter(isRecord7).map((entry) => String(entry.text ?? "")).join("\n");
   }
   return "";
 }
@@ -141568,10 +141899,10 @@ function isEmptyClaudeMessageEvent(event) {
     return false;
   }
   const message = event.message;
-  if (!isRecord5(message) || !Array.isArray(message.content)) {
+  if (!isRecord7(message) || !Array.isArray(message.content)) {
     return false;
   }
-  return !message.content.filter(isRecord5).some(hasVisibleClaudeContentBlock);
+  return !message.content.filter(isRecord7).some(hasVisibleClaudeContentBlock);
 }
 function shouldSkipClaudeTranscriptEvent(event) {
   return event.isMeta === true || event.isSidechain === true || event.type === "attachment" || event.type === "last-prompt" || isEmptyClaudeMessageEvent(event);
@@ -141585,13 +141916,13 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
   init() {
     const { tasks } = this.taskEngine.listTasks();
     for (const task of tasks) {
-      if (task.agent !== "claudecode") continue;
-      const sessionId = task.payload.sessionId;
-      if (!sessionId) continue;
-      const cwd = path10.resolve(
-        task.payload.sessionCwd ?? task.effectiveProjectPath ?? task.project ?? process.cwd()
-      );
-      this.sessions.set(task.id, { sessionId, cwd, title: task.title });
+      const session = getPersistedAgentSession(task, "claudecode");
+      if (!session) continue;
+      this.sessions.set(task.id, {
+        sessionId: session.sessionId,
+        cwd: path10.resolve(session.cwd || task.effectiveProjectPath || task.project || process.cwd()),
+        title: task.title
+      });
     }
     if (this.sessions.size > 0) {
       this.logger.info("Recovered sessions from store", { count: this.sessions.size });
@@ -141647,7 +141978,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
           this.persistSession(task.id, event.session_id, cwd);
           this.logger.info("Session established", { taskId: task.id, sessionId: event.session_id });
         }
-        const outputEvent = timestampClaudeTranscriptEvent(event);
+        const outputEvent = event.type === "system" && event.subtype === "init" && typeof event.session_id === "string" ? { ...timestampClaudeTranscriptEvent(event), agent: "claudecode" } : timestampClaudeTranscriptEvent(event);
         this.emitOutput(task.id, outputEvent);
         this.appendLog(task.id, outputEvent);
       } catch {
@@ -141664,7 +141995,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
     proc.stderr.on("data", (chunk) => {
       stderrBuffer += chunk.toString();
     });
-    proc.on("close", (code4) => {
+    proc.on("close", async (code4) => {
       if (buffer.trim()) {
         processLine(buffer);
       }
@@ -141673,6 +142004,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
         return;
       }
       try {
+        await this.flushLogsAndEmitReady(task.id);
         if (code4 === 0 && !streamError) {
           this.logger.info("Task completed successfully", { taskId: task.id, title: task.title });
           this.taskEngine.reportResult(task.id, { message: `Task "${task.title}" completed` });
@@ -141710,7 +142042,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
     this.writeUserMessage(proc.stdin, initialContent);
     proc.unref();
   }
-  sendMessage(taskId, content3) {
+  sendMessage(taskId, content3, options) {
     let session = this.sessions.get(taskId);
     if (!session) {
       const recovered = this.recoverSession(taskId);
@@ -141729,7 +142061,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
     if (!session) {
       throw new MeshyError("TASK_NOT_FOUND", `No active session for task ${taskId}`, 404);
     }
-    const userEvent = buildTaskUserLogEvent(content3);
+    const userEvent = buildTaskUserLogEvent(options?.logContent ?? content3);
     this.appendLog(taskId, userEvent);
     this.emitOutput(taskId, userEvent);
     this.logger.info("Sending follow-up message", { taskId, sessionId: session.sessionId });
@@ -141776,7 +142108,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
           });
           this.persistSession(taskId, event.session_id, session.cwd);
         }
-        const outputEvent = timestampClaudeTranscriptEvent(event);
+        const outputEvent = event.type === "system" && event.subtype === "init" && typeof event.session_id === "string" ? { ...timestampClaudeTranscriptEvent(event), agent: "claudecode" } : timestampClaudeTranscriptEvent(event);
         this.emitOutput(taskId, outputEvent);
         this.appendLog(taskId, outputEvent);
       } catch {
@@ -141793,7 +142125,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
     proc.stderr.on("data", (chunk) => {
       stderrBuffer += chunk.toString();
     });
-    proc.on("close", (code4) => {
+    proc.on("close", async (code4) => {
       if (buffer.trim()) {
         processLine(buffer);
       }
@@ -141802,6 +142134,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
         return;
       }
       try {
+        await this.flushLogsAndEmitReady(taskId);
         if (code4 === 0 && !streamError) {
           this.logger.info("Follow-up completed", { taskId, sessionId: session.sessionId });
           this.taskEngine.reportResult(taskId, { message: `Task "${session.title}" completed` });
@@ -141854,7 +142187,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
     try {
       const current = this.taskEngine.getTask(taskId);
       this.taskEngine.updateTask(taskId, {
-        payload: buildPersistedSessionPayload(current, sessionId, cwd)
+        payload: buildPersistedSessionPayload(current, sessionId, cwd, "claudecode")
       });
     } catch {
     }
@@ -141873,7 +142206,8 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
         const event = JSON.parse(line);
         if (event.type === "system" && event.subtype === "init" && typeof event.session_id === "string") {
           const task = this.taskEngine.getTask(taskId);
-          const persistedCwd = typeof task?.payload.sessionCwd === "string" ? task.payload.sessionCwd : void 0;
+          if (!canUseSessionLogEventForAgent(task, "claudecode", event)) continue;
+          const persistedCwd = getPersistedAgentSession(task, "claudecode")?.cwd ?? (typeof task?.payload.sessionCwd === "string" ? task.payload.sessionCwd : void 0);
           return {
             sessionId: event.session_id,
             cwd: path10.resolve(
@@ -141889,14 +142223,12 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
   }
   recoverPersistedSession(taskId) {
     const task = this.taskEngine.getTask(taskId);
-    const sessionId = typeof task?.payload.sessionId === "string" ? task.payload.sessionId : void 0;
-    if (!sessionId) {
-      return null;
-    }
+    const persisted = getPersistedAgentSession(task, "claudecode");
+    if (!persisted) return null;
     return {
-      sessionId,
+      sessionId: persisted.sessionId,
       cwd: path10.resolve(
-        (typeof task?.payload.sessionCwd === "string" ? task.payload.sessionCwd : void 0) ?? task?.effectiveProjectPath ?? task?.project ?? process.cwd()
+        persisted.cwd || task?.effectiveProjectPath || task?.project || process.cwd()
       ),
       title: task?.title ?? taskId
     };
@@ -141909,21 +142241,21 @@ var fs11 = __toESM(require("fs"), 1);
 var path11 = __toESM(require("path"), 1);
 var import_node_child_process5 = require("child_process");
 var CODEX_SESSION_MIRROR_INTERVAL_MS = 500;
-function isRecord6(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null;
 }
 function stableStringify(value) {
   if (Array.isArray(value)) {
     return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
   }
-  if (!isRecord6(value)) {
+  if (!isRecord8(value)) {
     return JSON.stringify(value);
   }
   return `{${Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key2, entryValue]) => `${JSON.stringify(key2)}:${stableStringify(entryValue)}`).join(",")}}`;
 }
 function transcriptEventSignature(event) {
   const message = event.message;
-  if ((event.type === "assistant" || event.type === "user") && isRecord6(message) && Array.isArray(message.content)) {
+  if ((event.type === "assistant" || event.type === "user") && isRecord8(message) && Array.isArray(message.content)) {
     return `${event.type}:${stableStringify(message.content)}`;
   }
   return stableStringify(event);
@@ -141962,9 +142294,6 @@ function splitPromptContent(content3) {
     images
   };
 }
-function hasImageContent(content3) {
-  return content3.some((part) => part.type === "image");
-}
 function buildCodexModeArgs(mode) {
   switch (mode) {
     case "plan":
@@ -141987,13 +142316,13 @@ var CodexEngine = class extends ExecutionEngine {
   init() {
     const { tasks } = this.taskEngine.listTasks();
     for (const task of tasks) {
-      if (task.agent !== "codex") continue;
-      const sessionId = task.payload.sessionId;
-      if (!sessionId) continue;
-      const cwd = path11.resolve(
-        task.payload.sessionCwd ?? task.effectiveProjectPath ?? task.project ?? process.cwd()
-      );
-      this.sessions.set(task.id, { sessionId, cwd, title: task.title });
+      const session = getPersistedAgentSession(task, "codex");
+      if (!session) continue;
+      this.sessions.set(task.id, {
+        sessionId: session.sessionId,
+        cwd: path11.resolve(session.cwd || task.effectiveProjectPath || task.project || process.cwd()),
+        title: task.title
+      });
     }
     if (this.sessions.size > 0) {
       this.logger.info("Recovered Codex sessions from store", { count: this.sessions.size });
@@ -142004,7 +142333,7 @@ var CodexEngine = class extends ExecutionEngine {
     const cwd = task.effectiveProjectPath ?? task.project ?? process.cwd();
     const initialContent = getTaskInitialMessageContent(task);
     const { prompt, imagePaths, promptEcho } = this.prepareAssets(task.id, initialContent);
-    this.markCodexPromptEchoEmitted(task.id, [promptEcho, prompt], hasImageContent(initialContent));
+    this.markCodexPromptEchoEmitted(task.id, [promptEcho, prompt]);
     const args = this.buildArgs(imagePaths, { model: config2.model, mode: config2.mode ?? "bypass" });
     this.ensureLogDir();
     this.logger.info("Spawning codex CLI", { taskId: task.id, title: task.title, cwd });
@@ -142017,7 +142346,7 @@ var CodexEngine = class extends ExecutionEngine {
     this.writePrompt(proc.stdin, prompt);
     proc.unref();
   }
-  sendMessage(taskId, content3) {
+  sendMessage(taskId, content3, options) {
     let session = this.sessions.get(taskId);
     if (!session) {
       const recovered = this.recoverSession(taskId);
@@ -142039,12 +142368,12 @@ var CodexEngine = class extends ExecutionEngine {
     const current = this.taskEngine.getTask(taskId);
     const model = typeof current?.payload.model === "string" ? current.payload.model : void 0;
     const mode = current?.payload.mode;
-    const userEvent = buildTaskUserLogEvent(content3);
+    const userEvent = buildTaskUserLogEvent(options?.logContent ?? content3);
     this.markTranscriptEventEmitted(taskId, userEvent);
     this.appendLog(taskId, userEvent);
     this.emitOutput(taskId, userEvent);
     const { prompt, imagePaths, promptEcho } = this.prepareAssets(taskId, content3);
-    this.markCodexPromptEchoEmitted(taskId, [promptEcho, prompt], hasImageContent(content3));
+    this.markCodexPromptEchoEmitted(taskId, [promptEcho, prompt]);
     const args = this.buildArgs(imagePaths, {
       model,
       sessionId: session.sessionId,
@@ -142103,7 +142432,7 @@ var CodexEngine = class extends ExecutionEngine {
     proc.stderr?.on("data", (chunk) => {
       stderrBuffer += chunk.toString();
     });
-    proc.on("close", (code4) => {
+    proc.on("close", async (code4) => {
       if (buffer.trim()) {
         processLine(buffer);
       }
@@ -142116,6 +142445,7 @@ var CodexEngine = class extends ExecutionEngine {
       try {
         this.flushNativeSessionMirror(taskId);
         this.flushPendingAmbiguousAssistantTextEvents(taskId);
+        await this.flushLogsAndEmitReady(taskId);
         if (code4 === 0) {
           this.logger.info(isFollowUp ? "Codex follow-up completed" : "Codex task completed successfully", {
             taskId,
@@ -142262,8 +142592,7 @@ var CodexEngine = class extends ExecutionEngine {
   markTranscriptEventEmitted(taskId, event) {
     this.getEmittedTranscriptSignatures(taskId).add(transcriptEventSignature(event));
   }
-  markCodexPromptEchoEmitted(taskId, prompts, hasImages) {
-    if (!hasImages) return;
+  markCodexPromptEchoEmitted(taskId, prompts) {
     for (const prompt of new Set(prompts.map((candidate) => candidate.trim()).filter(Boolean))) {
       this.markTranscriptEventEmitted(taskId, buildTaskUserLogEvent([{ type: "text", text: prompt }]));
     }
@@ -142302,8 +142631,9 @@ var CodexEngine = class extends ExecutionEngine {
         title
       });
       this.persistSession(taskId, event.thread_id, cwd);
-      this.appendLog(taskId, event);
-      this.emitOutput(taskId, event);
+      const sessionEvent = { ...event, agent: "codex" };
+      this.appendLog(taskId, sessionEvent);
+      this.emitOutput(taskId, sessionEvent);
       this.startNativeSessionMirror(taskId, event.thread_id);
       this.logger.info("Codex session established", { taskId, sessionId: event.thread_id });
       return [];
@@ -142348,7 +142678,7 @@ var CodexEngine = class extends ExecutionEngine {
     try {
       const current = this.taskEngine.getTask(taskId);
       this.taskEngine.updateTask(taskId, {
-        payload: buildPersistedSessionPayload(current, sessionId, cwd)
+        payload: buildPersistedSessionPayload(current, sessionId, cwd, "codex")
       });
     } catch {
     }
@@ -142367,7 +142697,8 @@ var CodexEngine = class extends ExecutionEngine {
         const event = JSON.parse(line);
         if (event.type === "thread.started" && typeof event.thread_id === "string") {
           const task = this.taskEngine.getTask(taskId);
-          const persistedCwd = typeof task?.payload.sessionCwd === "string" ? task.payload.sessionCwd : void 0;
+          if (!canUseSessionLogEventForAgent(task, "codex", event)) continue;
+          const persistedCwd = getPersistedAgentSession(task, "codex")?.cwd ?? (typeof task?.payload.sessionCwd === "string" ? task.payload.sessionCwd : void 0);
           return {
             sessionId: event.thread_id,
             cwd: path11.resolve(persistedCwd ?? task?.effectiveProjectPath ?? task?.project ?? process.cwd()),
@@ -142381,14 +142712,12 @@ var CodexEngine = class extends ExecutionEngine {
   }
   recoverPersistedSession(taskId) {
     const task = this.taskEngine.getTask(taskId);
-    const sessionId = typeof task?.payload.sessionId === "string" ? task.payload.sessionId : void 0;
-    if (!sessionId) {
-      return null;
-    }
+    const persisted = getPersistedAgentSession(task, "codex");
+    if (!persisted) return null;
     return {
-      sessionId,
+      sessionId: persisted.sessionId,
       cwd: path11.resolve(
-        (typeof task?.payload.sessionCwd === "string" ? task.payload.sessionCwd : void 0) ?? task?.effectiveProjectPath ?? task?.project ?? process.cwd()
+        persisted.cwd || task?.effectiveProjectPath || task?.project || process.cwd()
       ),
       title: task?.title ?? taskId
     };
@@ -142400,7 +142729,7 @@ init_cjs_shims();
 var fs12 = __toESM(require("fs"), 1);
 var path12 = __toESM(require("path"), 1);
 var import_node_child_process6 = require("child_process");
-function isRecord7(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null;
 }
 function contentToPrompt(content3) {
@@ -142438,7 +142767,7 @@ function inferExtension2(mediaType) {
   return normalized.replace(/[^a-z0-9]/g, "") || "bin";
 }
 function extractSessionId(event) {
-  const data = isRecord7(event.data) ? event.data : void 0;
+  const data = isRecord9(event.data) ? event.data : void 0;
   const direct = event.session_id ?? event.sessionId ?? event.conversation_id ?? event.conversationId ?? data?.sessionId ?? data?.session_id ?? data?.conversationId ?? data?.conversation_id;
   if (typeof direct === "string" && direct.trim()) return direct.trim();
   const type = typeof event.type === "string" ? event.type.toLowerCase() : "";
@@ -142452,13 +142781,13 @@ var CopilotCliEngine = class extends ExecutionEngine {
   init() {
     const { tasks } = this.taskEngine.listTasks();
     for (const task of tasks) {
-      if (task.agent !== "copilot") continue;
-      const sessionId = task.payload.sessionId;
-      if (!sessionId) continue;
-      const cwd = path12.resolve(
-        task.payload.sessionCwd ?? task.effectiveProjectPath ?? task.project ?? process.cwd()
-      );
-      this.sessions.set(task.id, { sessionId, cwd, title: task.title });
+      const session = getPersistedAgentSession(task, "copilot");
+      if (!session) continue;
+      this.sessions.set(task.id, {
+        sessionId: session.sessionId,
+        cwd: path12.resolve(session.cwd || task.effectiveProjectPath || task.project || process.cwd()),
+        title: task.title
+      });
     }
     if (this.sessions.size > 0) {
       this.logger.info("Recovered Copilot CLI sessions from store", { count: this.sessions.size });
@@ -142487,7 +142816,7 @@ var CopilotCliEngine = class extends ExecutionEngine {
     this.attachProcess(task.id, task.title, cwd, proc, false);
     proc.unref();
   }
-  sendMessage(taskId, content3) {
+  sendMessage(taskId, content3, options) {
     let session = this.sessions.get(taskId);
     if (!session) {
       const recovered = this.recoverSession(taskId) ?? this.recoverPersistedSession(taskId);
@@ -142504,7 +142833,7 @@ var CopilotCliEngine = class extends ExecutionEngine {
     const mode = current?.payload.mode;
     const systemPrompt = typeof current?.payload.systemPrompt === "string" ? current.payload.systemPrompt : void 0;
     const allowedTools = Array.isArray(current?.payload.allowedTools) && current.payload.allowedTools.every((tool) => typeof tool === "string") ? current.payload.allowedTools : void 0;
-    const userEvent = buildTaskUserLogEvent(content3);
+    const userEvent = buildTaskUserLogEvent(options?.logContent ?? content3);
     this.appendLog(taskId, userEvent);
     this.emitOutput(taskId, userEvent);
     const prompt = buildPrompt(content3, systemPrompt);
@@ -142597,7 +142926,7 @@ var CopilotCliEngine = class extends ExecutionEngine {
     proc.stderr?.on("data", (chunk) => {
       stderrBuffer += chunk.toString();
     });
-    proc.on("close", (code4) => {
+    proc.on("close", async (code4) => {
       if (buffer.trim()) {
         processLine(buffer);
       }
@@ -142606,6 +142935,7 @@ var CopilotCliEngine = class extends ExecutionEngine {
         return;
       }
       try {
+        await this.flushLogsAndEmitReady(taskId);
         if (code4 === 0) {
           this.logger.info(isFollowUp ? "Copilot CLI follow-up completed" : "Copilot CLI task completed successfully", {
             taskId,
@@ -142657,8 +142987,9 @@ var CopilotCliEngine = class extends ExecutionEngine {
     if (sessionId) {
       this.sessions.set(taskId, { sessionId, cwd, title });
       this.persistSession(taskId, sessionId, cwd);
-      this.appendLog(taskId, event);
-      this.emitOutput(taskId, event);
+      const sessionEvent = { ...event, agent: "copilot" };
+      this.appendLog(taskId, sessionEvent);
+      this.emitOutput(taskId, sessionEvent);
       this.logger.info("Copilot CLI session established", { taskId, sessionId });
       return [];
     }
@@ -142668,7 +142999,7 @@ var CopilotCliEngine = class extends ExecutionEngine {
     try {
       const current = this.taskEngine.getTask(taskId);
       this.taskEngine.updateTask(taskId, {
-        payload: buildPersistedSessionPayload(current, sessionId, cwd)
+        payload: buildPersistedSessionPayload(current, sessionId, cwd, "copilot")
       });
     } catch {
     }
@@ -142687,7 +143018,8 @@ var CopilotCliEngine = class extends ExecutionEngine {
         const sessionId = extractSessionId(event);
         if (sessionId) {
           const task = this.taskEngine.getTask(taskId);
-          const persistedCwd = typeof task?.payload.sessionCwd === "string" ? task.payload.sessionCwd : void 0;
+          if (!canUseSessionLogEventForAgent(task, "copilot", event)) continue;
+          const persistedCwd = getPersistedAgentSession(task, "copilot")?.cwd ?? (typeof task?.payload.sessionCwd === "string" ? task.payload.sessionCwd : void 0);
           return {
             sessionId,
             cwd: path12.resolve(persistedCwd ?? task?.effectiveProjectPath ?? task?.project ?? process.cwd()),
@@ -142701,12 +143033,12 @@ var CopilotCliEngine = class extends ExecutionEngine {
   }
   recoverPersistedSession(taskId) {
     const task = this.taskEngine.getTask(taskId);
-    const sessionId = typeof task?.payload.sessionId === "string" ? task.payload.sessionId : void 0;
-    if (!sessionId) return null;
+    const persisted = getPersistedAgentSession(task, "copilot");
+    if (!persisted) return null;
     return {
-      sessionId,
+      sessionId: persisted.sessionId,
       cwd: path12.resolve(
-        (typeof task?.payload.sessionCwd === "string" ? task.payload.sessionCwd : void 0) ?? task?.effectiveProjectPath ?? task?.project ?? process.cwd()
+        persisted.cwd || task?.effectiveProjectPath || task?.project || process.cwd()
       ),
       title: task?.title ?? taskId
     };
@@ -144136,22 +144468,33 @@ async function handleLocalNodeMessage(deps, message) {
     const payload = message.payload;
     if (!payload.taskId || !payload.content) return;
     const task = deps.taskEngine.getTask(payload.taskId);
-    const engine = task ? deps.engineRegistry.get(task.agent) : void 0;
-    if (!task || !engine) return;
-    deps.taskEngine.updateTask(payload.taskId, { status: "running" });
+    const agent = task ? resolveActiveAgent(task, payload.targetAgent) : void 0;
+    const engine = agent ? deps.engineRegistry.get(agent) : void 0;
+    if (!task || !agent || !engine) return;
     if (!deps.nodeRegistry.isLeader()) {
       const reporter = new RestLeaderTaskReporter(deps.nodeRegistry, log2);
       reporter.reportRunning(payload.taskId, { branch: task.branch });
-      registerLeaderForwarding(deps.eventBus, deps.nodeRegistry, log2, payload.taskId, task.agent, reporter);
+      registerLeaderForwarding(deps.eventBus, deps.nodeRegistry, log2, payload.taskId, agent, reporter);
     }
     try {
-      engine.sendMessage(payload.taskId, payload.content);
-      log2.info("started keepalive-delivered follow-up execution", { taskId: payload.taskId });
+      startAgentTaskTurn({
+        task,
+        content: payload.content,
+        targetAgent: payload.targetAgent,
+        assignedTo: task.assignedTo,
+        taskEngine: deps.taskEngine,
+        engineRegistry: deps.engineRegistry,
+        eventBus: deps.eventBus,
+        logger: log2
+      });
+      log2.info("started keepalive-delivered follow-up execution", { taskId: payload.taskId, agent });
     } catch (error2) {
-      log2.warn("failed to start keepalive-delivered follow-up execution", {
+      const messageText = error2 instanceof Error ? error2.message : String(error2);
+      log2.error("failed to start keepalive-delivered follow-up execution", {
         taskId: payload.taskId,
-        error: error2 instanceof Error ? error2.message : String(error2)
+        error: messageText
       });
+      deps.taskEngine.reportFailure(payload.taskId, `Engine follow-up failed before execution started: ${messageText}`);
     }
     return;
   }
@@ -144308,14 +144651,15 @@ var MeshyNode = class {
     };
     this.nodeRegistry.setSelf(this.selfInfo);
     this.nodeRegistry.upsertNode(this.selfInfo);
-    this.heartbeat.setNodeMessageHandler((message) => handleLocalNodeMessage({
+    const localNodeMessageHandler = (message) => handleLocalNodeMessage({
       taskEngine: this.taskEngine,
       engineRegistry: this.engineRegistry,
       nodeRegistry: this.nodeRegistry,
       eventBus: this.eventBus,
       logger: this.logger,
       getWorkDir: () => this.getWorkDir()
-    }, message));
+    }, message);
+    this.heartbeat.setNodeMessageHandler(localNodeMessageHandler);
     this.nodeMessageClient = new NodeMessageClient({ heartbeat: this.heartbeat, logger: this.logger });
     this.taskDispatcher = new TaskDispatcher(
       this.taskEngine,
@@ -144324,7 +144668,8 @@ var MeshyNode = class {
       this.eventBus,
       { autoAssignInterval: 5e3, dispatchTimeout: 1e4 },
       this.logger,
-      this.nodeMessageClient
+      this.nodeMessageClient,
+      localNodeMessageHandler
     );
     this.dataRouter = new DataRouter(this.nodeRegistry, this.election);
     const seeds = this.config.cluster.seeds;
@@ -145366,6 +145711,7 @@ var SystemAgentInfoSchema = external_exports.object({
     detail: external_exports.string().nullable().optional()
   }).optional()
 });
+var DefaultTaskAgentSchema = external_exports.enum(["codex", "claudecode", "copilot"]);
 var SystemRuntimeUpdateInfoSchema = external_exports.object({
   packageName: external_exports.string(),
   currentVersion: external_exports.string().nullable(),
@@ -145380,6 +145726,7 @@ var NodeSettingsSnapshotSchema = external_exports.object({
   version: external_exports.string(),
   packageName: external_exports.string().optional(),
   uptime: external_exports.number(),
+  defaultTaskAgent: DefaultTaskAgentSchema.optional(),
   auth: SystemAuthInfoSchema.optional(),
   os: SystemOsInfoSchema.optional(),
   runtime: SystemRuntimeInfoSchema.optional(),
@@ -145721,6 +146068,10 @@ var QuickChatsResponse = external_exports.object({
 var ReplaceQuickChatsBody = external_exports.object({
   quickChats: external_exports.array(QuickChatItem).max(100)
 });
+var DefaultTaskAgentResponse = external_exports.object({
+  defaultTaskAgent: DefaultTaskAgentSchema
+});
+var UpdateDefaultTaskAgentBody = DefaultTaskAgentResponse;
 
 // ../../packages/api/src/schemas/tasks.ts
 init_cjs_shims();
@@ -145772,6 +146123,7 @@ var TaskListResponse = external_exports.object({
     queuedMessages: external_exports.array(external_exports.object({
       id: external_exports.string(),
       content: external_exports.array(external_exports.record(external_exports.unknown())).min(1),
+      targetAgent: external_exports.enum(NATIVE_SESSION_AGENT_OPTIONS).optional(),
       createdAt: external_exports.number()
     })).optional(),
     status: external_exports.enum(["pending", "assigned", "running", "completed", "failed", "cancelled", "archived"]),
@@ -145838,12 +146190,15 @@ var TaskMessageContentPart = external_exports.union([
 var TaskMessageContent = external_exports.array(TaskMessageContentPart).min(1);
 var SendMessageBody = external_exports.union([
   external_exports.object({
-    content: TaskMessageContent
+    content: TaskMessageContent,
+    targetAgent: external_exports.enum(NATIVE_SESSION_AGENT_OPTIONS).optional()
   }),
   external_exports.object({
-    message: external_exports.string().trim().min(1)
+    message: external_exports.string().trim().min(1),
+    targetAgent: external_exports.enum(NATIVE_SESSION_AGENT_OPTIONS).optional()
   }).transform((value) => ({
-    content: [{ type: "text", text: value.message }]
+    content: [{ type: "text", text: value.message }],
+    ...value.targetAgent ? { targetAgent: value.targetAgent } : {}
   }))
 ]);
 var AttachNativeSessionBody = external_exports.object({
@@ -145860,7 +146215,8 @@ var WorkerImportTaskBody = external_exports.object({
   logs: external_exports.array(TaskLogEvent).default([])
 });
 var TaskLogsQuery = external_exports.object({
-  after: external_exports.coerce.number().int().min(0).optional()
+  after: external_exports.coerce.number().int().min(0).optional(),
+  minTotal: external_exports.coerce.number().int().min(0).optional()
 });
 var CreateTaskShareBody = external_exports.object({
   tenant: external_exports.string().trim().min(1).max(128).default(DEFAULT_TASK_SHARE_TENANT),
@@ -146282,6 +146638,7 @@ function durationMs(startedAt) {
 }
 function createRequestLoggingMiddleware(rootLogger, options = {}) {
   const log2 = rootLogger.child("api/request");
+  const lastLoggedAt = /* @__PURE__ */ new Map();
   return (req, res, next2) => {
     if (options.shouldLog && !options.shouldLog(req)) {
       next2();
@@ -146293,6 +146650,16 @@ function createRequestLoggingMiddleware(rootLogger, options = {}) {
     const logCompletion = (closed) => {
       if (logged) return;
       logged = true;
+      const throttle = options.throttle;
+      if (throttle && throttle.intervalMs > 0 && throttle.shouldThrottle(req, res, closed, path47)) {
+        const now = throttle.now?.() ?? Date.now();
+        const key2 = throttle.key?.(req, path47) ?? `${req.method.toUpperCase()} ${path47}`;
+        const previousLoggedAt = lastLoggedAt.get(key2);
+        if (previousLoggedAt !== void 0 && now - previousLoggedAt < throttle.intervalMs) {
+          return;
+        }
+        lastLoggedAt.set(key2, now);
+      }
       log2.info("request completed", {
         method: req.method,
         path: path47,
@@ -146413,8 +146780,21 @@ var sharedMcpControl;
 var DEFAULT_START_POLL_INTERVAL_MS = 1e4;
 var DEFAULT_START_TIMEOUT_MS = 15 * 6e4;
 var ALWAYS_ONLINE_STARTABLE_DEVBOX_STATUSES = /* @__PURE__ */ new Set(["hibernated", "stopped"]);
+var DEVBOX_MCP_NODE_VERSION = "22";
 var DEVBOX_MCP_COMMAND = "npx";
-var DEVBOX_MCP_ARGS = ["-y", "-p", "node@22", "-p", "@microsoft/devbox-mcp@latest", "devbox-mcp-server"];
+var DEVBOX_MCP_ARGS = ["-y", "-p", `node@${DEVBOX_MCP_NODE_VERSION}`, "-p", "@microsoft/devbox-mcp@latest", "devbox-mcp-server"];
+var DEVBOX_MCP_DISPLAY_COMMAND = `${DEVBOX_MCP_COMMAND} ${DEVBOX_MCP_ARGS.join(" ")}`;
+function asDevBoxMcpError(err) {
+  if (err instanceof MeshyError) return err;
+  const cause = err instanceof Error ? err.message : String(err);
+  if (!/connection closed/iu.test(cause)) return err;
+  return new MeshyError(
+    "DEVBOX_MCP_UNAVAILABLE",
+    `Unable to reach the DevBox MCP server: it closed the connection. Meshy runs @microsoft/devbox-mcp with Node.js ${DEVBOX_MCP_NODE_VERSION} via npx; check that npx can install packages and Azure Dev Box authentication is available, then try again.`,
+    502,
+    { cause, command: DEVBOX_MCP_DISPLAY_COMMAND }
+  );
+}
 function getDevBoxControl(deps) {
   if (deps.devBoxControl) return deps.devBoxControl;
   sharedMcpControl ??= new McpDevBoxControl(deps.logger);
@@ -146557,7 +146937,7 @@ var McpDevBoxControl = class {
       return await client.callTool({ name: name2, arguments: args });
     } catch (err) {
       this.clientPromise = null;
-      throw err;
+      throw asDevBoxMcpError(err);
     }
   }
   async getClient() {
@@ -146595,13 +146975,13 @@ function cleanDevBoxInfo(devbox) {
 }
 function normalizeMcpDevBoxList(value) {
   const normalized = normalizeMcpValue(value);
-  const record2 = isRecord8(normalized) ? normalized : {};
+  const record2 = isRecord10(normalized) ? normalized : {};
   const list4 = Array.isArray(normalized) ? normalized : Array.isArray(record2.devboxes) ? record2.devboxes : Array.isArray(record2.value) ? record2.value : [];
   return list4.map((item) => normalizeDevBoxResource(item, void 0)).filter((item) => Boolean(item.name));
 }
 function normalizeDevBoxResource(value, fallback) {
   const record2 = normalizeRecord(value);
-  const additional = isRecord8(record2.additionalProperties) ? record2.additionalProperties : {};
+  const additional = isRecord10(record2.additionalProperties) ? record2.additionalProperties : {};
   const fromUri = parseDevBoxUri(readString(record2, "uri"));
   const status = readString(record2, "status") ?? readString(record2, "powerState") ?? readString(record2, "lastStatus") ?? fallback?.lastStatus;
   const name2 = readString(record2, "name") ?? fromUri?.name ?? fallback?.name ?? "";
@@ -146655,7 +147035,7 @@ function parseDevCenterEndpoint(hostname6) {
 }
 function normalizeRecord(value) {
   const normalized = normalizeMcpValue(value);
-  return isRecord8(normalized) ? normalized : {};
+  return isRecord10(normalized) ? normalized : {};
 }
 function normalizeMcpValue(value) {
   if (Array.isArray(value)) return value;
@@ -146690,7 +147070,7 @@ function tryParseJson(text10) {
     return null;
   }
 }
-function isRecord8(value) {
+function isRecord10(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function readString(record2, key2) {
@@ -147982,6 +148362,7 @@ function buildNodeSettingsSnapshot(options) {
     version: runtimeMetadata?.packageVersion ?? "0.1.0",
     packageName: runtimeMetadata?.packageName ?? "meshy",
     uptime,
+    defaultTaskAgent: options.defaultTaskAgent,
     auth: options.auth,
     os: getOsSnapshot(),
     runtime: {
@@ -148014,6 +148395,7 @@ function buildSystemInfo(deps) {
   };
   const settingsSnapshot = buildNodeSettingsSnapshot({
     auth,
+    defaultTaskAgent: deps.storagePath ? resolveNodeDefaultTaskAgent(deps.storagePath) : "codex",
     inspectRuntimeTools: deps.inspectRuntimeTools,
     localDashboardOrigin: deps.localDashboardOrigin,
     runtimeMetadata: deps.runtimeMetadata,
@@ -148027,6 +148409,7 @@ function buildSystemInfo(deps) {
     version: settingsSnapshot.version,
     packageName: settingsSnapshot.packageName,
     uptime: settingsSnapshot.uptime,
+    defaultTaskAgent: settingsSnapshot.defaultTaskAgent,
     transportType: deps.getTransportType?.() ?? "direct",
     dashboardOrigin: deps.dashboardOrigin ?? self2.dashboardOrigin,
     localDashboardOrigin: deps.localDashboardOrigin,
@@ -148117,7 +148500,7 @@ function upgradeRuntimeAgentForDeps(deps, agent) {
 // ../../packages/api/src/node/runtime-restart-request.ts
 init_cjs_shims();
 function parseRuntimeRestartRequest(value) {
-  const body3 = isRecord9(value) ? value : {};
+  const body3 = isRecord11(value) ? value : {};
   const startArgs = parseRuntimeRestartStartArgs(body3.startArgs);
   return {
     reason: body3.reason === "update" ? "update" : "restart",
@@ -148126,7 +148509,7 @@ function parseRuntimeRestartRequest(value) {
 }
 function parseRuntimeRestartStartArgs(value) {
   if (value === void 0) return void 0;
-  if (!isRecord9(value)) {
+  if (!isRecord11(value)) {
     throw new MeshyError("VALIDATION_ERROR", "Runtime restart startArgs must be an object", 400);
   }
   const startArgs = {};
@@ -148175,7 +148558,7 @@ function parseOptionalString(value, key2) {
   const trimmed = value.trim();
   return trimmed || void 0;
 }
-function isRecord9(value) {
+function isRecord11(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
@@ -149196,7 +149579,7 @@ function toLegacyWorkerControl2(message) {
 }
 
 // ../../packages/api/src/tasks/task-route-utils.ts
-function isRecord10(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null;
 }
 function restoreTaskState(taskEngine, task) {
@@ -149263,7 +149646,7 @@ function normalizeStructuredValue(value) {
   if (Array.isArray(value)) {
     return value.map((entry) => normalizeStructuredValue(entry));
   }
-  if (!isRecord10(value)) {
+  if (!isRecord12(value)) {
     return value;
   }
   return Object.fromEntries(
@@ -149272,20 +149655,20 @@ function normalizeStructuredValue(value) {
 }
 function getTranscriptEventSignature(event) {
   if (event.type === "user") {
-    const signature = getTaskUserMessageSignature(isRecord10(event.message) ? event.message.content : event.message) ?? getTaskUserMessageSignature(event.content);
+    const signature = getTaskUserMessageSignature(isRecord12(event.message) ? event.message.content : event.message) ?? getTaskUserMessageSignature(event.content);
     return signature ? `user:${signature}` : null;
   }
   if (event.type === "assistant") {
     if (typeof event.message === "string") {
       return `assistant:${JSON.stringify(event.message)}`;
     }
-    if (isRecord10(event.message) && "content" in event.message) {
+    if (isRecord12(event.message) && "content" in event.message) {
       return `assistant:${JSON.stringify(normalizeStructuredValue(event.message.content))}`;
     }
     if (Array.isArray(event.content)) {
       return `assistant:${JSON.stringify(normalizeStructuredValue(event.content))}`;
     }
-    if (isRecord10(event.message)) {
+    if (isRecord12(event.message)) {
       return `assistant:${JSON.stringify(normalizeStructuredValue(event.message))}`;
     }
   }
@@ -177128,22 +177511,32 @@ async function handleTaskMessage(deps, message) {
   if (!task) {
     throw new MeshyError("TASK_NOT_FOUND", `Task ${payload.taskId} not found`, 404);
   }
-  if (!supportsFollowUpAgent(task.agent)) {
-    throw new MeshyError("VALIDATION_ERROR", `Agent ${task.agent} does not support chat messages`, 400);
+  const targetAgent = typeof payload.targetAgent === "string" ? payload.targetAgent : void 0;
+  const agent = resolveActiveAgent(task, targetAgent);
+  if (!supportsFollowUpAgent(agent)) {
+    throw new MeshyError("VALIDATION_ERROR", `Agent ${agent} does not support chat messages`, 400);
   }
-  const engine = deps.engineRegistry.get(task.agent);
+  const engine = deps.engineRegistry.get(agent);
   if (!engine) {
-    throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${task.agent}`, 400);
+    throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${agent}`, 400);
   }
-  deps.taskEngine.updateTask(payload.taskId, { status: "running" });
   if (!deps.nodeRegistry.isLeader()) {
     const reporter = new RestLeaderTaskReporter(deps.nodeRegistry, log2);
     reporter.reportRunning(payload.taskId, { branch: task.branch });
-    registerLeaderForwarding(deps.eventBus, deps.nodeRegistry, log2, payload.taskId, task.agent, reporter);
+    registerLeaderForwarding(deps.eventBus, deps.nodeRegistry, log2, payload.taskId, agent, reporter);
   }
   try {
-    engine.sendMessage(payload.taskId, payload.content);
-    log2.info("started follow-up execution", { taskId: payload.taskId });
+    startAgentTaskTurn({
+      task,
+      content: payload.content,
+      targetAgent,
+      assignedTo: task.assignedTo,
+      taskEngine: deps.taskEngine,
+      engineRegistry: deps.engineRegistry,
+      eventBus: deps.eventBus,
+      logger: log2
+    });
+    log2.info("started follow-up execution", { taskId: payload.taskId, agent });
   } catch (error2) {
     const messageText = error2 instanceof Error ? error2.message : String(error2);
     log2.error("engine.sendMessage threw synchronously", { taskId: payload.taskId, error: messageText });
@@ -177394,6 +177787,7 @@ async function sendTaskLogsResponse(req, res, taskId) {
   const log2 = rootLogger.child("tasks/logs");
   const query = TaskLogsQuery.parse(req.query);
   const after = query.after ?? 0;
+  const minTotal = query.minTotal ?? 0;
   const proxyRequest = getTaskLogsProxyRequestMetadata(req);
   let task = taskEngine.getTask(taskId);
   if (!task && proxyRequest.task?.id === taskId) {
@@ -177439,7 +177833,8 @@ async function sendTaskLogsResponse(req, res, taskId) {
   if (isLeader) {
     const local2 = readLocalTaskLogsWithNativeHistory(engineRegistry, task, taskId, after, task?.agent ?? "claudecode");
     leaderLocal = local2;
-    if ((local2.total > 0 || !needsProxy) && !shouldAskWorkerForNativeRepair) {
+    const leaderLocalSatisfiesCheckpoint = minTotal === 0 || local2.total >= minTotal;
+    if ((local2.total > 0 || !needsProxy) && leaderLocalSatisfiesCheckpoint && !shouldAskWorkerForNativeRepair) {
       log2.debug("serving leader-local task logs", {
         taskId,
         assignedTo: task?.assignedTo,
@@ -177450,7 +177845,16 @@ async function sendTaskLogsResponse(req, res, taskId) {
       res.json(local2);
       return;
     }
-    if (local2.total > 0 && shouldAskWorkerForNativeRepair) {
+    if (local2.total > 0 && !leaderLocalSatisfiesCheckpoint) {
+      log2.debug("leader-local task logs behind requested checkpoint, falling back to worker proxy", {
+        taskId,
+        assignedTo: task?.assignedTo,
+        selfId,
+        total: local2.total,
+        minTotal,
+        after
+      });
+    } else if (local2.total > 0 && shouldAskWorkerForNativeRepair) {
       log2.debug("leader-local native session logs may be partial, checking worker repair path", {
         taskId,
         assignedTo: task?.assignedTo,
@@ -177493,7 +177897,9 @@ async function sendTaskLogsResponse(req, res, taskId) {
           return;
         }
       }
-      const proxyPath = `/api/tasks/${taskId}/logs?after=${after}`;
+      const proxyParams = new URLSearchParams({ after: String(after) });
+      if (minTotal > 0) proxyParams.set("minTotal", String(minTotal));
+      const proxyPath = `/api/tasks/${taskId}/logs?${proxyParams.toString()}`;
       try {
         const { endpoint, response: proxyRes } = await fetchNodeWithFallback(
           node2,
@@ -177548,17 +177954,24 @@ init_cjs_shims();
 
 // ../../packages/api/src/tasks/task-follow-up.ts
 init_cjs_shims();
-function startLocalTaskFollowUp(deps, task, content3, assignedTo, metadata) {
-  const engine = deps.engineRegistry.get(task.agent);
+function startLocalTaskFollowUp(deps, task, content3, assignedTo, targetAgent, metadata) {
+  const agent = resolveActiveAgent(task, targetAgent);
+  const engine = deps.engineRegistry.get(agent);
   if (!engine) {
-    throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${task.agent}`, 400);
+    throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${agent}`, 400);
   }
-  deps.taskEngine.updateTask(task.id, {
-    status: "running",
-    assignedTo
-  });
   try {
-    engine.sendMessage(task.id, content3);
+    startAgentTaskTurn({
+      task,
+      content: content3,
+      targetAgent,
+      assignedTo,
+      taskEngine: deps.taskEngine,
+      engineRegistry: deps.engineRegistry,
+      eventBus: deps.eventBus,
+      logger: deps.logger,
+      metadata
+    });
   } catch (err) {
     restoreTaskState(deps.taskEngine, task);
     deps.logger.warn("failed to start local follow-up execution", {
@@ -177581,9 +177994,10 @@ function restoreQueuedMessage(taskEngine, taskId, message) {
     queuedMessages: [message, ...current.queuedMessages ?? []]
   });
 }
-async function sendTaskFollowUpMessage(deps, task, content3, metadata) {
-  if (!supportsFollowUpAgent(task.agent)) {
-    throw new MeshyError("VALIDATION_ERROR", `Agent ${task.agent} does not support chat messages`, 400);
+async function sendTaskFollowUpMessage(deps, task, content3, targetAgent, metadata) {
+  const agent = resolveActiveAgent(task, targetAgent);
+  if (!supportsFollowUpAgent(agent)) {
+    throw new MeshyError("VALIDATION_ERROR", `Agent ${agent} does not support chat messages`, 400);
   }
   if (task.assignedTo && task.assignedTo !== deps.nodeRegistry.getSelf()?.id) {
     const node2 = deps.nodeRegistry.getNode(task.assignedTo);
@@ -177602,7 +178016,7 @@ async function sendTaskFollowUpMessage(deps, task, content3, metadata) {
         409
       );
     }
-    deps.taskEngine.updateTask(task.id, { status: "running" });
+    deps.taskEngine.updateTask(task.id, targetAgent ? { status: "running", payload: { ...task.payload, activeAgent: agent } } : { status: "running" });
     log2.info("proxying follow-up message to worker", {
       taskId: task.id,
       assignedTo: task.assignedTo,
@@ -177612,7 +178026,8 @@ async function sendTaskFollowUpMessage(deps, task, content3, metadata) {
       const client = new NodeMessageClient({ heartbeat: deps.heartbeat, logger: deps.logger });
       const delivery = await client.send(node2, createNodeMessage("task.message", {
         taskId: task.id,
-        content: content3
+        content: content3,
+        ...targetAgent ? { targetAgent } : {}
       }));
       return delivery.queued ? { queued: true } : {};
     } catch (err) {
@@ -177630,31 +178045,34 @@ async function sendTaskFollowUpMessage(deps, task, content3, metadata) {
   startLocalTaskFollowUp({
     taskEngine: deps.taskEngine,
     engineRegistry: deps.engineRegistry,
+    eventBus: deps.eventBus,
     logger: deps.logger.child("tasks/message")
-  }, task, content3, task.assignedTo, metadata);
+  }, task, content3, task.assignedTo, targetAgent, metadata);
   return {};
 }
-function queueRunningTaskMessage(deps, task, content3) {
-  if (!supportsFollowUpAgent(task.agent)) {
-    throw new MeshyError("VALIDATION_ERROR", `Agent ${task.agent} does not support chat messages`, 400);
+function queueRunningTaskMessage(deps, task, content3, targetAgent) {
+  const agent = resolveActiveAgent(task, targetAgent);
+  if (!supportsFollowUpAgent(agent)) {
+    throw new MeshyError("VALIDATION_ERROR", `Agent ${agent} does not support chat messages`, 400);
   }
-  const queued = deps.taskEngine.enqueueTaskMessage(task.id, content3);
+  const queued = targetAgent ? deps.taskEngine.enqueueTaskMessage(task.id, content3, targetAgent) : deps.taskEngine.enqueueTaskMessage(task.id, content3);
   deps.logger.child("tasks/message").info("queued follow-up message for running task", {
     taskId: task.id,
+    targetAgent,
     queuedCount: queued.queuedMessages?.length ?? 0
   });
   return queued;
 }
 var MESSAGEABLE_STATUSES = /* @__PURE__ */ new Set(["running", "completed", "cancelled", "failed"]);
-async function applyTaskMessage(deps, task, content3) {
+async function applyTaskMessage(deps, task, content3, targetAgent) {
   if (!MESSAGEABLE_STATUSES.has(task.status)) {
     throw new MeshyError("VALIDATION_ERROR", `Cannot send message to task in ${task.status} status`, 400);
   }
   if (task.status === "running") {
-    const queued = queueRunningTaskMessage(deps, task, content3);
+    const queued = queueRunningTaskMessage(deps, task, content3, targetAgent);
     return { ok: true, queued: true, queuedMessages: queued.queuedMessages ?? [] };
   }
-  const result = await sendTaskFollowUpMessage(deps, task, content3);
+  const result = await sendTaskFollowUpMessage(deps, task, content3, targetAgent);
   return result.queued ? { ok: true, queued: true } : { ok: true };
 }
 function cancelQueuedTaskMessage(deps, taskId, messageId) {
@@ -177687,7 +178105,7 @@ async function drainNextQueuedTaskMessage(deps, taskId) {
   if (!dequeued) return false;
   drainingTaskIds.add(taskId);
   try {
-    await sendTaskFollowUpMessage(deps, dequeued.task, dequeued.message.content, {
+    await sendTaskFollowUpMessage(deps, dequeued.task, dequeued.message.content, dequeued.message.targetAgent, {
       queuedMessageId: dequeued.message.id
     });
     deps.logger.child("tasks/message").info("started queued follow-up message", {
@@ -178671,7 +179089,7 @@ function createTaskRoutes() {
     res.json({ ok: true, queuedMessages: task.queuedMessages ?? [] });
   }));
   router.post("/:id/message", asyncHandler8(async (req, res) => {
-    const { taskEngine, engineRegistry, nodeRegistry, heartbeat, logger: rootLogger } = req.app.locals.deps;
+    const { taskEngine, engineRegistry, nodeRegistry, heartbeat, eventBus, logger: rootLogger } = req.app.locals.deps;
     const body3 = SendMessageBody.parse(req.body);
     const taskId = req.params.id;
     const task = taskEngine.getTask(taskId);
@@ -178679,9 +179097,10 @@ function createTaskRoutes() {
       throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
     }
     res.json(await applyTaskMessage(
-      { taskEngine, engineRegistry, nodeRegistry, heartbeat, logger: rootLogger },
+      { taskEngine, engineRegistry, nodeRegistry, heartbeat, eventBus, logger: rootLogger },
       task,
-      body3.content
+      body3.content,
+      body3.targetAgent
     ));
   }));
   router.use(createTaskOutputRoutes());
@@ -178855,6 +179274,10 @@ var WorkerMessageBody = external_exports.object({
 var WorkerTaskBody = external_exports.object({
   taskId: external_exports.string().min(1)
 });
+var WorkerLogsReadyBody = external_exports.object({
+  taskId: external_exports.string().min(1),
+  total: external_exports.number().int().min(0)
+});
 function asyncHandler10(fn) {
   return (req, res, next2) => fn(req, res, next2).catch(next2);
 }
@@ -178909,15 +179332,15 @@ function createWorkerRoutes() {
     if (!task) {
       throw new MeshyError("TASK_NOT_FOUND", `Task ${body3.taskId} not found`, 404);
     }
-    if (!supportsFollowUpAgent(task.agent)) {
-      throw new MeshyError("VALIDATION_ERROR", `Agent ${task.agent} does not support chat messages`, 400);
+    const agent = resolveActiveAgent(task, body3.targetAgent);
+    if (!supportsFollowUpAgent(agent)) {
+      throw new MeshyError("VALIDATION_ERROR", `Agent ${agent} does not support chat messages`, 400);
     }
-    const engine = engineRegistry.get(task.agent);
+    const engine = engineRegistry.get(agent);
     if (!engine) {
-      res.status(400).json({ error: `Engine not registered for agent: ${task.agent}` });
+      res.status(400).json({ error: `Engine not registered for agent: ${agent}` });
       return;
     }
-    taskEngine.updateTask(body3.taskId, { status: "running" });
     if (!nodeRegistry.isLeader()) {
       new RestLeaderTaskReporter(nodeRegistry, log2).reportRunning(body3.taskId, { branch: task.branch });
     }
@@ -178928,13 +179351,22 @@ function createWorkerRoutes() {
         nodeRegistry,
         log2,
         body3.taskId,
-        task.agent,
+        agent,
         new RestLeaderTaskReporter(nodeRegistry, log2)
       );
     }
     try {
-      engine.sendMessage(body3.taskId, body3.content);
-      log2.info("started follow-up execution", { taskId: body3.taskId });
+      startAgentTaskTurn({
+        task,
+        content: body3.content,
+        targetAgent: body3.targetAgent,
+        assignedTo: task.assignedTo,
+        taskEngine,
+        engineRegistry,
+        eventBus,
+        logger: log2
+      });
+      log2.info("started follow-up execution", { taskId: body3.taskId, agent });
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
       log2.error("engine.sendMessage threw synchronously", { taskId: body3.taskId, error: errorMessage });
@@ -178986,6 +179418,12 @@ function createWorkerRoutes() {
     }
     res.json({ ok: true });
   }));
+  router.post("/logs-ready", asyncHandler10(async (req, res) => {
+    const { eventBus } = req.app.locals.deps;
+    const body3 = WorkerLogsReadyBody.parse(req.body);
+    eventBus.emit("task.logs.ready", { taskId: body3.taskId, total: body3.total });
+    res.json({ ok: true });
+  }));
   router.post("/heartbeat", asyncHandler10(async (req, res) => {
     const { heartbeat, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("worker/heartbeat");
@@ -179156,6 +179594,10 @@ function getQuickChatStore(deps) {
   if (deps.storagePath) return createQuickChatStore(deps.storagePath);
   throw new MeshyError("VALIDATION_ERROR", "Quick chats are not available for this node", 501);
 }
+function getStoragePath2(deps) {
+  if (deps.storagePath) return deps.storagePath;
+  throw new MeshyError("VALIDATION_ERROR", "Node metadata is not available for this node", 501);
+}
 function validateQuickChatAliases(quickChats) {
   const seen = /* @__PURE__ */ new Set();
   for (const quickChat of quickChats) {
@@ -179248,6 +179690,21 @@ function createSystemRoutes() {
     const metrics2 = taskEngine.getMetrics();
     res.json(metrics2);
   }));
+  router.get("/default-task-agent", asyncHandler11(async (req, res) => {
+    const storagePath = getStoragePath2(req.app.locals.deps);
+    res.json({ defaultTaskAgent: resolveNodeDefaultTaskAgent(storagePath) });
+  }));
+  router.put("/default-task-agent", asyncHandler11(async (req, res) => {
+    const body3 = UpdateDefaultTaskAgentBody.parse(req.body);
+    const deps = req.app.locals.deps;
+    const storagePath = getStoragePath2(deps);
+    persistNodeDefaultTaskAgent(storagePath, body3.defaultTaskAgent);
+    const settingsSnapshot = deps.refreshSettingsSnapshot?.();
+    if (settingsSnapshot) {
+      deps.nodeRegistry.updateSettingsSnapshot(deps.nodeRegistry.getSelf().id, settingsSnapshot);
+    }
+    res.json({ defaultTaskAgent: resolveNodeDefaultTaskAgent(storagePath) });
+  }));
   router.get("/quick-chats", asyncHandler11(async (req, res) => {
     const store = getQuickChatStore(req.app.locals.deps);
     res.json({ quickChats: store.list() });
@@ -179284,6 +179741,7 @@ var ALL_EVENT_NAMES = [
   "task.updated",
   "task.deleted",
   "task.output",
+  "task.logs.ready",
   "election.started",
   "election.complete",
   "cluster.state",
@@ -179590,12 +180048,22 @@ var REQUEST_TELEMETRY_SUPPRESSED_ROUTES = /* @__PURE__ */ new Set([
   "POST /api/cluster-control/heartbeat",
   "POST /api/cluster-control/keepalive"
 ]);
+var REQUEST_LOGGING_THROTTLED_ROUTES = /* @__PURE__ */ new Set([
+  "POST /api/worker/keepalive",
+  "POST /api/cluster-control/keepalive"
+]);
+var REQUEST_LOGGING_THROTTLE_MS = 6e4;
 function normalizeRequestTelemetryPath(pathname) {
   return pathname.length > 1 ? pathname.replace(/\/+$/, "") : pathname;
 }
+function requestRouteKey(method, pathname) {
+  return `${method.toUpperCase()} ${normalizeRequestTelemetryPath(pathname)}`;
+}
 function isSuppressedRequestTelemetryRoute(req) {
-  const key2 = `${req.method.toUpperCase()} ${normalizeRequestTelemetryPath(req.path)}`;
-  return REQUEST_TELEMETRY_SUPPRESSED_ROUTES.has(key2);
+  return REQUEST_TELEMETRY_SUPPRESSED_ROUTES.has(requestRouteKey(req.method, req.path));
+}
+function isThrottledRequestLoggingRoute(method, pathname) {
+  return REQUEST_LOGGING_THROTTLED_ROUTES.has(requestRouteKey(method, pathname));
 }
 function usesLargeJsonBodyLimit(pathname) {
   return pathname === "/api/cluster/join" || pathname === "/api/node" || pathname.startsWith("/api/node/") || pathname === "/api/tasks" || pathname.startsWith("/api/tasks/") || pathname === "/api/worker" || pathname.startsWith("/api/worker/") || pathname.startsWith("/api/mobile/");
@@ -179767,7 +180235,11 @@ function createServer2(deps) {
   const canServeDashboard = (req) => !deps.config.validateBearerToken || isTrustedDashboardRequest(req, authConfig);
   const canServePreview = (req) => canServeDashboard(req) || hasAuthorizationHeader(req);
   app.use(createRequestLoggingMiddleware(deps.logger, {
-    shouldLog: (req) => isApiRequest(req) || isPreviewRequest(req)
+    shouldLog: (req) => isApiRequest(req) || isPreviewRequest(req),
+    throttle: {
+      intervalMs: REQUEST_LOGGING_THROTTLE_MS,
+      shouldThrottle: (req, res, closed, path47) => !closed && res.statusCode < 400 && isThrottledRequestLoggingRoute(req.method, path47)
+    }
   }));
   app.use(createRequestTelemetryMiddleware(deps.telemetry ?? createNoopTelemetry(), {
     shouldTrack: (req) => !isSuppressedRequestTelemetryRoute(req) && (isApiRequest(req) || isPreviewRequest(req))
@@ -181756,6 +182228,7 @@ function createSettingsSnapshotProvider(options) {
   function buildSnapshot() {
     cachedSnapshot = buildNodeSettingsSnapshot({
       auth: options.authMetadata,
+      defaultTaskAgent: resolveNodeDefaultTaskAgent(options.storagePath),
       localDashboardOrigin: options.localDashboardOrigin,
       runtimeMetadata: options.runtimeMetadata,
       runtimeUpdate: createRuntimeUpdateSnapshot({