openfox 1.6.52 → 1.6.53

package/dist/{chunk-BMNBXLFY.js → chunk-JLMCJLTK.js}

@@ -1,19 +1,13 @@
-import {
-  generateSessionName,
-  needsNameGeneration
-} from "./chunk-OPT4YF7X.js";
 import {
   createVerifierNudgeConfig,
   runBuilderTurn,
   runChatTurn
-} from "./chunk-PLIGDCWB.js";
+} from "./chunk-4MSEK56X.js";
 import {
   TurnMetrics,
   agentExists,
-  assembleAgentRequest,
   cancelPathConfirmationsForSession,
   checkAborted,
-  createChatDoneEvent,
   createMessageStartEvent,
   createToolRegistry,
   deleteAgent,
@@ -22,13 +16,11 @@ import {
   executeSubAgent,
   findAgentById,
   findSkillById,
-  getAllInstructions,
   getDefaultAgentContent,
   getDefaultAgentIds,
   getDefaultIds,
   getDefaultSkillContent,
   getDefaultSkillIds,
-  getEnabledSkillMetadata,
   getToolRegistryForAgent,
   isSkillEnabled,
   loadAllAgents,
@@ -39,7 +31,6 @@ import {
   loadItemsFromDir,
   loadUserAgents,
   loadUserSkills,
-  maybeAutoCompactContext,
   pathExists,
   performManualContextCompaction,
   saveAgent,
@@ -47,7 +38,7 @@ import {
   setSkillEnabled,
   skillExists,
   spawnShellProcess
-} from "./chunk-NVWJC2YZ.js";
+} from "./chunk-DAUVWS5W.js";
 import {
   getPathSeparator,
   getPlatformShell,
@@ -99,7 +90,6 @@ import {
   updateSessionSummary
 } from "./chunk-UQGY56XJ.js";
 import {
-  buildContextMessagesFromEventHistory,
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
 } from "./chunk-LIMBYVO4.js";
@@ -108,17 +98,15 @@ import {
   createChatMessageMessage,
   createContextStateMessage,
   createErrorMessage,
-  createPhaseChangedMessage,
   createQueueStateMessage,
   createSessionRunningMessage,
   createSessionStateMessage,
   isAskAnswerPayload,
-  isChatSendPayload,
   isSessionLoadPayload,
   parseClientMessage,
   serializeServerMessage,
   storedEventToServerMessage
-} from "./chunk-HQSCGJ6V.js";
+} from "./chunk-5STJLSGO.js";
 import {
   EventEmitter,
   cancelQuestionsForSession,
@@ -132,7 +120,7 @@ import {
 } from "./chunk-B7E3BICY.js";
 import {
   createServerMessage
-} from "./chunk-H5ZZGLQU.js";
+} from "./chunk-CTAIXOZJ.js";
 import {
   getGlobalConfigDir
 } from "./chunk-R4HADRYO.js";
@@ -2006,81 +1994,6 @@ async function runOrchestrator(options) {
   return executeWorkflow(workflow, options);
 }
 
-// src/server/session/summary-generator.ts
-var SUMMARY_INSTRUCTION = "Write a 2-3 sentence summary of what the user wants to accomplish. Focus on WHAT and WHY, not HOW. Output only the summary, no preamble.";
-async function generateSessionSummary(options) {
-  const { messages, llmClient, workdir, customInstructions, skills } = options;
-  try {
-    const messagesText = messages.map((m) => `${m.role}: ${m.content}`).join("\n");
-    const userPrompt = `${SUMMARY_INSTRUCTION}
-
-## Conversation History
-${messagesText}
-
-## Summary`;
-    const contextMessages = [
-      {
-        role: "user",
-        content: userPrompt,
-        source: "history"
-      }
-    ];
-    const mockAgentDef = {
-      metadata: {
-        id: "summary",
-        name: "Summary",
-        description: "Session summary generator",
-        subagent: false,
-        allowedTools: []
-      },
-      prompt: SUMMARY_INSTRUCTION
-    };
-    const assembledRequest = assembleAgentRequest({
-      agentDef: mockAgentDef,
-      workdir,
-      messages: contextMessages,
-      injectedFiles: [],
-      ...customInstructions ? { customInstructions } : {},
-      ...skills ? { skills } : {},
-      promptTools: [],
-      toolChoice: "none",
-      disableThinking: true
-    });
-    const llmMessages = assembledRequest.messages.map((msg) => ({
-      role: msg.role,
-      content: msg.content
-    }));
-    const response = await llmClient.complete({
-      messages: llmMessages,
-      tools: [],
-      signal: AbortSignal.timeout(6e4),
-      disableThinking: true
-    });
-    let summary = response.content.trim();
-    if (summary.length > 500) {
-      summary = summary.substring(0, 497) + "...";
-    }
-    if (!summary || summary.length < 10) {
-      return {
-        success: false,
-        error: "Generated summary is too short or empty"
-      };
-    }
-    return {
-      success: true,
-      summary
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error generating summary"
-    };
-  }
-}
-function needsSummaryGeneration(sessionSummary) {
-  return sessionSummary === null || sessionSummary.trim() === "";
-}
-
 // src/server/auth.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join2, dirname as dirname2 } from "path";
@@ -2206,24 +2119,6 @@ async function isValidToken(token) {
 }
 
 // src/server/ws/server.ts
-function getCurrentWindowMessageOptions2(sessionId) {
-  const contextWindowId = getCurrentContextWindowId(sessionId);
-  return contextWindowId ? { contextWindowId } : void 0;
-}
-function getSessionMessageCount(sessionId) {
-  const eventStore = getEventStore();
-  const events = eventStore.getEvents(sessionId);
-  let count = 0;
-  for (const event of events) {
-    if (event.type === "message.start") {
-      const data = event.data;
-      if (data.role === "user") {
-        count++;
-      }
-    }
-  }
-  return count;
-}
 function resolveStatsIdentity(llmClient, getActiveProvider) {
   const provider = getActiveProvider?.();
   const model = llmClient.getModel();
@@ -2235,6 +2130,45 @@ function resolveStatsIdentity(llmClient, getActiveProvider) {
     model
   };
 }
+function buildSessionState(sessionManager, sessionId) {
+  const session = sessionManager.getSession(sessionId);
+  if (!session) {
+    return { session: null, messages: [], pendingConfirmations: [] };
+  }
+  const eventStore = getEventStore();
+  const events = eventStore.getEvents(sessionId);
+  const messages = events.length > 0 ? buildMessagesFromStoredEvents(events) : [];
+  const pendingConfirmations = foldPendingConfirmations(events);
+  return { session, messages, pendingConfirmations };
+}
+function addUserMessageAndBroadcast(sessionManager, sessionId, message, broadcastFn) {
+  const userMessage = sessionManager.addMessage(sessionId, {
+    role: "user",
+    content: message.content,
+    ...message.attachments ? { attachments: message.attachments } : {},
+    ...message.messageKind ? { messageKind: message.messageKind } : {}
+  });
+  broadcastFn(sessionId, createChatMessageMessage(userMessage));
+  return userMessage;
+}
+function processQueueAndRestartTurn(sessionManager, sessionId, drainFn, queueMode, broadcastFn, activeAgents2, startTurnFn, queueMessageFn) {
+  const messages = drainFn(sessionId);
+  const next = messages[0];
+  if (!next) return false;
+  for (const remaining of messages.slice(1)) {
+    if (queueMessageFn) {
+      queueMessageFn(sessionId, queueMode, remaining.content, remaining.attachments, remaining.messageKind);
+    } else {
+      sessionManager.queueMessage(sessionId, queueMode, remaining.content, remaining.attachments);
+    }
+  }
+  broadcastFn(sessionId, createQueueStateMessage(sessionManager.getQueueState(sessionId)));
+  addUserMessageAndBroadcast(sessionManager, sessionId, { content: next.content, ...next.attachments ? { attachments: next.attachments } : {}, ...next.messageKind ? { messageKind: next.messageKind } : {} }, broadcastFn);
+  const newController = new AbortController();
+  activeAgents2.set(sessionId, newController);
+  startTurnFn(sessionId, newController);
+  return true;
+}
 var activeAgents = /* @__PURE__ */ new Map();
 function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvider, sessionManager, providerManager) {
   const wss = new WebSocketServer({ server: httpServer });
@@ -2302,6 +2236,43 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
   };
   const llmForSession = (sessionId) => getSessionLLMClient?.(sessionId) ?? getLLMClient();
   const statsForSession = (sessionId) => getSessionStatsIdentity?.(sessionId) ?? resolveStatsIdentity(getLLMClient(), getActiveProvider);
+  function cleanupAfterTurn(sessionId, controller, sendFn, setRunningOnEarlyReturn) {
+    if (activeAgents.get(sessionId) !== controller) {
+      return;
+    }
+    activeAgents.delete(sessionId);
+    const processed = processQueueAndRestartTurn(
+      sessionManager,
+      sessionId,
+      (sid) => sessionManager.drainAsapMessages(sid),
+      "asap",
+      sendFn,
+      activeAgents,
+      startTurnWithCompletionChain,
+      (sid, mode, content, attachments, messageKind) => sessionManager.queueMessage(sid, mode, content, attachments, messageKind)
+    );
+    if (processed) {
+      if (setRunningOnEarlyReturn) sessionManager.setRunning(sessionId, false);
+      return;
+    }
+    const processedCompletion = processQueueAndRestartTurn(
+      sessionManager,
+      sessionId,
+      (sid) => sessionManager.drainCompletionMessages(sid),
+      "completion",
+      sendFn,
+      activeAgents,
+      startTurnWithCompletionChain
+    );
+    if (processedCompletion) {
+      if (setRunningOnEarlyReturn) sessionManager.setRunning(sessionId, false);
+      return;
+    }
+    sessionManager.clearMessageQueue(sessionId);
+    sessionManager.setRunning(sessionId, false);
+    const contextState = sessionManager.getContextState(sessionId);
+    sendFn(sessionId, createContextStateMessage(contextState));
+  }
   function startTurnWithCompletionChain(sessionId, controller) {
     runChatTurn({
       sessionManager,
@@ -2316,51 +2287,7 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
       }
       logger.error("Chat turn error", { error });
     }).finally(() => {
-      if (activeAgents.get(sessionId) !== controller) {
-        return;
-      }
-      activeAgents.delete(sessionId);
-      const asapMsgs = sessionManager.drainAsapMessages(sessionId);
-      const nextAsap = asapMsgs[0];
-      if (nextAsap) {
-        for (const remaining of asapMsgs.slice(1)) {
-          sessionManager.queueMessage(sessionId, "asap", remaining.content, remaining.attachments, remaining.messageKind);
-        }
-        broadcastForSession(sessionId, createQueueStateMessage(sessionManager.getQueueState(sessionId)));
-        const userMessagePayload = {
-          role: "user",
-          content: nextAsap.content,
-          ...nextAsap.attachments ? { attachments: nextAsap.attachments } : {}
-        };
-        const userMessage = sessionManager.addMessage(sessionId, userMessagePayload);
-        broadcastForSession(sessionId, createChatMessageMessage(userMessage));
-        const newController = new AbortController();
-        activeAgents.set(sessionId, newController);
-        startTurnWithCompletionChain(sessionId, newController);
-        return;
-      }
-      const completionMsgs = sessionManager.drainCompletionMessages(sessionId);
-      const next = completionMsgs[0];
-      if (next) {
-        for (const remaining of completionMsgs.slice(1)) {
-          sessionManager.queueMessage(sessionId, "completion", remaining.content, remaining.attachments);
-        }
-        broadcastForSession(sessionId, createQueueStateMessage(sessionManager.getQueueState(sessionId)));
-        const userMessage = sessionManager.addMessage(sessionId, {
-          role: "user",
-          content: next.content,
-          ...next.attachments ? { attachments: next.attachments } : {}
-        });
-        broadcastForSession(sessionId, createChatMessageMessage(userMessage));
-        const newController = new AbortController();
-        activeAgents.set(sessionId, newController);
-        startTurnWithCompletionChain(sessionId, newController);
-        return;
-      }
-      sessionManager.clearMessageQueue(sessionId);
-      sessionManager.setRunning(sessionId, false);
-      const contextState = sessionManager.getContextState(sessionId);
-      broadcastForSession(sessionId, createContextStateMessage(contextState));
+      cleanupAfterTurn(sessionId, controller, broadcastForSession, false);
     });
   }
   function triggerQueueProcessing(sessionId) {
@@ -2381,13 +2308,7 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
     const nextAsap = queue.find((m) => m.mode === "asap") ?? queue[0];
     if (nextAsap) {
       sessionManager.cancelQueuedMessage(sessionId, nextAsap.queueId);
-      const userMessage = sessionManager.addMessage(sessionId, {
-        role: "user",
-        content: nextAsap.content,
-        ...nextAsap.attachments ? { attachments: nextAsap.attachments } : {},
-        ...nextAsap.messageKind ? { messageKind: nextAsap.messageKind } : {}
-      });
-      broadcastForSession(sessionId, createChatMessageMessage(userMessage));
+      addUserMessageAndBroadcast(sessionManager, sessionId, { content: nextAsap.content, ...nextAsap.attachments ? { attachments: nextAsap.attachments } : {}, ...nextAsap.messageKind ? { messageKind: nextAsap.messageKind } : {} }, broadcastForSession);
     }
     startTurnWithCompletionChain(sessionId, controller);
     return true;
@@ -2400,22 +2321,15 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
       if (event.type === "session_created") {
         const session = sessionManager.getSession(sessionId);
         if (session) {
-          const eventStore = getEventStore();
-          const events = eventStore.getEvents(sessionId);
-          const messages = events.length > 0 ? buildMessagesFromStoredEvents(events) : [];
-          const pendingConfirmations = foldPendingConfirmations(events);
+          const { messages, pendingConfirmations } = buildSessionState(sessionManager, sessionId);
           ws.send(serializeServerMessage({ ...createSessionStateMessage(session, messages, pendingConfirmations), sessionId }));
         }
         continue;
       }
       if (isSubscribedToSession(client, sessionId)) {
         if (event.type === "session_updated") {
-          const session = sessionManager.getSession(sessionId);
+          const { session, messages, pendingConfirmations } = buildSessionState(sessionManager, sessionId);
           if (session) {
-            const eventStore = getEventStore();
-            const events = eventStore.getEvents(sessionId);
-            const messages = events.length > 0 ? buildMessagesFromStoredEvents(events) : [];
-            const pendingConfirmations = foldPendingConfirmations(events);
             ws.send(serializeServerMessage({ ...createSessionStateMessage(session, messages, pendingConfirmations), sessionId }));
           }
         }
@@ -2500,7 +2414,7 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
       }
       const client = clients.get(ws);
       try {
-        await handleClientMessage(ws, client, message, getLLMClient, getActiveProvider, sessionManager, broadcastForSession, providerManager, getSessionLLMClient, getSessionStatsIdentity, llmForSession, statsForSession, startTurnWithCompletionChain);
+        await handleClientMessage(ws, client, message, getLLMClient, getActiveProvider, sessionManager, broadcastForSession, providerManager, getSessionLLMClient, getSessionStatsIdentity, llmForSession, statsForSession, startTurnWithCompletionChain, cleanupAfterTurn);
       } catch (error) {
         logger.error("Error handling client message", { error, type: message.type });
         ws.send(serializeServerMessage(
@@ -2540,7 +2454,7 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
     broadcastForSession
   };
 }
-async function handleClientMessage(ws, client, message, getLLMClient, getActiveProvider, sessionManager, broadcastForSession, providerManager, getSessionLLMClient, getSessionStatsIdentity, llmForSession, statsForSession, startTurnWithCompletionChain) {
+async function handleClientMessage(ws, client, message, getLLMClient, getActiveProvider, sessionManager, broadcastForSession, providerManager, getSessionLLMClient, getSessionStatsIdentity, llmForSession, statsForSession, startTurnWithCompletionChain, cleanupAfterTurn) {
   const send = (msg) => {
     if (ws.readyState === WebSocket2.OPEN) {
       ws.send(serializeServerMessage(msg));
@@ -2616,308 +2530,6 @@ async function handleClientMessage(ws, client, message, getLLMClient, getActiveP
       break;
     }
     // =========================================================================
-    // Unified Chat (replaces plan.message, agent.start, etc.) - WS REQUIRED
-    // =========================================================================
-    case "chat.send": {
-      if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
-        return;
-      }
-      if (!isChatSendPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid chat.send payload", message.id));
-        return;
-      }
-      const currentSession = sessionManager.requireSession(client.activeSessionId);
-      if (currentSession.isRunning) {
-        send(createErrorMessage("ALREADY_RUNNING", "Session is already running", message.id));
-        return;
-      }
-      if (currentSession.phase === "blocked") {
-        logger.info("User intervention - resetting blocked state", { sessionId: client.activeSessionId });
-        sessionManager.setPhase(client.activeSessionId, "build");
-        sessionManager.resetAllCriteriaAttempts(client.activeSessionId);
-        sendForSession(client.activeSessionId, createPhaseChangedMessage("build"));
-      }
-      const sessionId = client.activeSessionId;
-      const eventStore = getEventStore();
-      ensureEventStoreSubscription(sessionId);
-      const controller = new AbortController();
-      const existingController = activeAgents.get(sessionId);
-      if (existingController) {
-        logger.warn("Aborting existing agent before starting new one", { sessionId });
-        existingController.abort();
-      }
-      activeAgents.set(sessionId, controller);
-      sessionManager.setRunning(sessionId, true);
-      sendForSession(sessionId, createSessionRunningMessage(true));
-      send({ type: "ack", payload: {}, id: message.id });
-      try {
-        await maybeAutoCompactContext({
-          sessionManager,
-          sessionId,
-          llmClient: llmForSession(sessionId),
-          statsIdentity: statsForSession(sessionId),
-          signal: controller.signal
-        });
-        if (controller.signal.aborted) {
-          break;
-        }
-        const userMessage = sessionManager.addMessage(sessionId, {
-          role: "user",
-          content: message.payload.content,
-          ...message.payload.attachments && { attachments: message.payload.attachments },
-          ...message.payload.messageKind && { messageKind: message.payload.messageKind },
-          ...message.payload.isSystemGenerated && { isSystemGenerated: message.payload.isSystemGenerated }
-        });
-        sendForSession(sessionId, createChatMessageMessage(userMessage));
-        const messageCount = getSessionMessageCount(sessionId);
-        if (needsNameGeneration(currentSession.metadata.title, messageCount)) {
-          generateSessionName({
-            userMessage: message.payload.content,
-            llmClient: llmForSession(sessionId),
-            signal: controller.signal
-          }).then(async (result) => {
-            if (result.success && result.name) {
-              updateSessionMetadata(sessionId, { title: result.name });
-              eventStore.append(sessionId, {
-                type: "session.name_generated",
-                data: { name: result.name }
-              });
-              const updatedSession = sessionManager.getSession(sessionId);
-              if (updatedSession) {
-                const events = eventStore.getEvents(sessionId);
-                const messages = buildMessagesFromStoredEvents(events);
-                const pendingConfirmations = foldPendingConfirmations(events);
-                broadcastForSession(sessionId, createSessionStateMessage(updatedSession, messages, pendingConfirmations));
-              }
-              logger.info("Session name generated", { sessionId, name: result.name });
-            }
-          }).catch((error) => {
-            logger.warn("Session name generation failed", { sessionId, error: error instanceof Error ? error.message : error });
-          });
-        }
-        startTurnWithCompletionChain(sessionId, controller);
-      } catch (error) {
-        if (activeAgents.get(sessionId) === controller) {
-          activeAgents.delete(sessionId);
-        }
-        sessionManager.setRunning(sessionId, false);
-        sendForSession(sessionId, createSessionRunningMessage(false));
-        const contextState = sessionManager.getContextState(sessionId);
-        sendForSession(sessionId, createContextStateMessage(contextState));
-        if (!(error instanceof Error && error.message === "Aborted")) {
-          logger.error("Chat send pre-turn error", { sessionId, error });
-        }
-      }
-      break;
-    }
-    case "chat.stop": {
-      send(createErrorMessage("DEPRECATED", "chat.stop removed. Use REST API: POST /api/sessions/:id/stop", message.id));
-      break;
-    }
-    // =========================================================================
-    // Message Queue
-    // =========================================================================
-    case "queue.asap": {
-      send(createErrorMessage("DEPRECATED", "queue.asap removed. Use REST API: POST /api/sessions/:id/queue/asap", message.id));
-      break;
-    }
-    case "queue.completion": {
-      send(createErrorMessage("DEPRECATED", "queue.completion removed. Use REST API: POST /api/sessions/:id/queue/completion", message.id));
-      break;
-    }
-    case "queue.cancel": {
-      send(createErrorMessage("DEPRECATED", "queue.cancel removed. Use REST API: DELETE /api/sessions/:id/queue/:queueId", message.id));
-      break;
-    }
-    case "chat.continue": {
-      send(createErrorMessage("DEPRECATED", "chat.continue removed. Use REST API: POST /api/sessions/:id/continue", message.id));
-      break;
-    }
-    // =========================================================================
-    // Mode Switching
-    // =========================================================================
-    case "mode.switch": {
-      send(createErrorMessage("DEPRECATED", "mode.switch removed. Use REST API: PUT /api/sessions/:id/mode", message.id));
-      break;
-    }
-    case "mode.accept": {
-      if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
-        return;
-      }
-      const session = sessionManager.requireSession(client.activeSessionId);
-      const acceptPayload = message.payload;
-      if (session.isRunning) {
-        const content = acceptPayload?.content ?? "";
-        const attachments = acceptPayload?.attachments;
-        const workflowId = acceptPayload?.workflowId;
-        let fullContent = content;
-        if (workflowId) {
-          const workflowInfo = `// Workflow: ${workflowId}`;
-          fullContent = content ? `${workflowInfo}
-
-${content}` : workflowInfo;
-        }
-        sessionManager.queueMessage(client.activeSessionId, "asap", fullContent, attachments, "workflow-accept");
-        const queueState = sessionManager.getQueueState(client.activeSessionId);
-        send({
-          type: "queue.state",
-          payload: { success: true, queueState },
-          id: message.id
-        });
-        return;
-      }
-      const acceptPayloadEarly = message.payload;
-      if (!acceptPayloadEarly?.workflowId && session.criteria.length === 0) {
-        send(createErrorMessage("NO_CRITERIA", "Cannot accept: no criteria defined", message.id));
-        return;
-      }
-      const sessionId = client.activeSessionId;
-      const eventStore = getEventStore();
-      send({ type: "ack", payload: {}, id: message.id });
-      sessionManager.setRunning(sessionId, true);
-      eventStore.append(sessionId, { type: "running.changed", data: { isRunning: true } });
-      sendForSession(sessionId, createSessionRunningMessage(true));
-      const currentSession = sessionManager.requireSession(sessionId);
-      if (needsSummaryGeneration(currentSession.summary)) {
-        const events = eventStore.getEvents(sessionId);
-        const nonSystemEvents = events.filter((event) => {
-          if (event.type !== "message.start") return true;
-          return event.data.isSystemGenerated !== true;
-        });
-        const contextMessages = buildContextMessagesFromEventHistory(nonSystemEvents);
-        const summaryMessages = contextMessages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({ role: m.role, content: m.content }));
-        if (summaryMessages.length > 0) {
-          const config = getRuntimeConfig();
-          const configDir = getGlobalConfigDir(config.mode ?? "production");
-          const skills = await getEnabledSkillMetadata(configDir);
-          const { content: instructions } = await getAllInstructions(currentSession.workdir, currentSession.projectId);
-          generateSessionSummary({
-            messages: summaryMessages,
-            llmClient: llmForSession(sessionId),
-            workdir: currentSession.workdir,
-            customInstructions: instructions || void 0,
-            skills
-          }).then(async (result) => {
-            if (result.success && result.summary) {
-              sessionManager.setSummary(sessionId, result.summary);
-            }
-          }).catch((error) => {
-            logger.warn("Session summary generation failed", { sessionId, error: error instanceof Error ? error.message : error });
-          });
-        }
-      }
-      ;
-      (async () => {
-        let controller = null;
-        try {
-          sessionManager.setMode(sessionId, "builder");
-          sessionManager.setPhase(sessionId, "build");
-          eventStore.append(sessionId, { type: "mode.changed", data: { mode: "builder", auto: false, reason: "Criteria accepted" } });
-          eventStore.append(sessionId, { type: "phase.changed", data: { phase: "build" } });
-          controller = new AbortController();
-          const existingController = activeAgents.get(sessionId);
-          if (existingController) {
-            logger.warn("Aborting existing agent before starting new one", { sessionId });
-            existingController.abort();
-          }
-          activeAgents.set(sessionId, controller);
-          const acceptPayload2 = message.payload;
-          const acceptAttachments = acceptPayload2?.attachments;
-          const hasAcceptContent = acceptPayload2?.content && typeof acceptPayload2.content === "string" && acceptPayload2.content.trim();
-          const hasAcceptAttachments = acceptAttachments && acceptAttachments.length > 0;
-          const hasAcceptMessage = hasAcceptContent || hasAcceptAttachments;
-          await runOrchestrator({
-            sessionManager,
-            sessionId,
-            llmClient: llmForSession(sessionId),
-            statsIdentity: statsForSession(sessionId),
-            injectBuilderKickoff: !hasAcceptMessage,
-            ...acceptPayload2?.workflowId ? { workflowId: acceptPayload2.workflowId } : {},
-            ...hasAcceptMessage ? { userMessage: { content: hasAcceptContent ? acceptPayload2.content : "", ...hasAcceptAttachments ? { attachments: acceptAttachments } : {} } } : {},
-            signal: controller.signal,
-            onMessage: (msg) => sendForSession(sessionId, msg)
-            // For path confirmation dialogs
-          });
-        } catch (error) {
-          if (error instanceof Error && error.message === "Aborted") {
-            return;
-          }
-          logger.error("mode.accept error", { error });
-          eventStore.append(sessionId, {
-            type: "chat.error",
-            data: {
-              error: error instanceof Error ? error.message : "Unknown error",
-              recoverable: false
-            }
-          });
-          const errorMsgId = crypto.randomUUID();
-          eventStore.append(sessionId, createMessageStartEvent(errorMsgId, "user", `Error: ${error instanceof Error ? error.message : "Unknown error"}`, {
-            ...getCurrentWindowMessageOptions2(sessionId) ?? {},
-            isSystemGenerated: true,
-            messageKind: "correction"
-          }));
-          eventStore.append(sessionId, { type: "message.done", data: { messageId: errorMsgId } });
-          eventStore.append(sessionId, createChatDoneEvent(errorMsgId, "error"));
-        } finally {
-          if (!controller || activeAgents.get(sessionId) !== controller) {
-            return;
-          }
-          activeAgents.delete(sessionId);
-          const completionMsgs = sessionManager.drainCompletionMessages(sessionId);
-          const nextCompletion = completionMsgs[0];
-          if (nextCompletion) {
-            for (const remaining of completionMsgs.slice(1)) {
-              sessionManager.queueMessage(sessionId, "completion", remaining.content, remaining.attachments);
-            }
-            sendForSession(sessionId, createQueueStateMessage(sessionManager.getQueueState(sessionId)));
-            const userMessage = sessionManager.addMessage(sessionId, {
-              role: "user",
-              content: nextCompletion.content,
-              ...nextCompletion.attachments ? { attachments: nextCompletion.attachments } : {}
-            });
-            sendForSession(sessionId, createChatMessageMessage(userMessage));
-            const newController = new AbortController();
-            activeAgents.set(sessionId, newController);
-            startTurnWithCompletionChain(sessionId, newController);
-            return;
-          }
-          const asapMsgs = sessionManager.drainAsapMessages(sessionId);
-          const nextAsap = asapMsgs[0];
-          if (nextAsap) {
-            for (const remaining of asapMsgs.slice(1)) {
-              sessionManager.queueMessage(sessionId, "asap", remaining.content, remaining.attachments, remaining.messageKind);
-            }
-            sendForSession(sessionId, createQueueStateMessage(sessionManager.getQueueState(sessionId)));
-            const userMessage = sessionManager.addMessage(sessionId, {
-              role: "user",
-              content: nextAsap.content,
-              ...nextAsap.attachments ? { attachments: nextAsap.attachments } : {}
-            });
-            sendForSession(sessionId, createChatMessageMessage(userMessage));
-            const newerController = new AbortController();
-            activeAgents.set(sessionId, newerController);
-            startTurnWithCompletionChain(sessionId, newerController);
-            return;
-          }
-          sessionManager.clearMessageQueue(sessionId);
-          sessionManager.setRunning(sessionId, false);
-          eventStore.append(sessionId, { type: "running.changed", data: { isRunning: false } });
-          const contextState = sessionManager.getContextState(sessionId);
-          sendForSession(sessionId, createContextStateMessage(contextState));
-        }
-      })();
-      break;
-    }
-    // =========================================================================
-    // Criteria Editing
-    // =========================================================================
-    case "criteria.edit": {
-      send(createErrorMessage("DEPRECATED", "criteria.edit removed. Use REST API: PUT /api/sessions/:id/criteria", message.id));
-      break;
-    }
-    // =========================================================================
     // Context Management
     // =========================================================================
     case "context.compact": {
@@ -3041,48 +2653,7 @@ ${content}` : workflowInfo;
         }
         logger.error("Runner error", { error, sessionId });
       }).finally(() => {
-        if (activeAgents.get(sessionId) !== controller) {
-          return;
-        }
-        activeAgents.delete(sessionId);
-        const asapMsgs = sessionManager.drainAsapMessages(sessionId);
-        const nextAsap = asapMsgs[0];
-        if (nextAsap) {
-          for (const remaining of asapMsgs.slice(1)) {
-            sessionManager.queueMessage(sessionId, "asap", remaining.content, remaining.attachments, remaining.messageKind);
-          }
-          sendForSession(sessionId, createQueueStateMessage(sessionManager.getQueueState(sessionId)));
-          const userMessage = sessionManager.addMessage(sessionId, {
-            role: "user",
-            content: nextAsap.content,
-            ...nextAsap.attachments ? { attachments: nextAsap.attachments } : {}
-          });
-          sendForSession(sessionId, createChatMessageMessage(userMessage));
-          const newerController = new AbortController();
-          activeAgents.set(sessionId, newerController);
-          startTurnWithCompletionChain(sessionId, newerController);
-          return;
-        }
-        const completionMsgs = sessionManager.drainCompletionMessages(sessionId);
-        const nextCompletion = completionMsgs[0];
-        if (nextCompletion) {
-          for (const remaining of completionMsgs.slice(1)) {
-            sessionManager.queueMessage(sessionId, "completion", remaining.content, remaining.attachments);
-          }
-          sendForSession(sessionId, createQueueStateMessage(sessionManager.getQueueState(sessionId)));
-          const userMessage = sessionManager.addMessage(sessionId, {
-            role: "user",
-            content: nextCompletion.content,
-            ...nextCompletion.attachments ? { attachments: nextCompletion.attachments } : {}
-          });
-          sendForSession(sessionId, createChatMessageMessage(userMessage));
-          const newController = new AbortController();
-          activeAgents.set(sessionId, newController);
-          startTurnWithCompletionChain(sessionId, newController);
-          return;
-        }
-        sessionManager.clearMessageQueue(sessionId);
-        sessionManager.setRunning(sessionId, false);
+        cleanupAfterTurn(sessionId, controller, sendForSession, true);
       });
       break;
     }
@@ -5487,7 +5058,7 @@ function createTerminalRoutes() {
 }
 
 // src/constants.ts
-var VERSION = "1.6.52";
+var VERSION = "1.6.53";
 
 // src/server/index.ts
 var __dirname2 = dirname5(fileURLToPath4(import.meta.url));
@@ -5789,14 +5360,14 @@ async function createServerHandle(config) {
     if (!callId || approved === void 0) {
       return res.status(400).json({ error: "callId and approved are required" });
     }
-    const { providePathConfirmation: providePathConfirmation2 } = await import("./tools-DTNPLRKJ.js");
+    const { providePathConfirmation: providePathConfirmation2 } = await import("./tools-SJN7IGVF.js");
     const result = providePathConfirmation2(callId, approved, alwaysAllow);
     if (!result.found) {
       return res.status(404).json({ error: "No pending path confirmation with that ID" });
     }
     const { getEventStore: getEventStore2 } = await import("./events-UCHHTT6X.js");
     const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2, foldPendingConfirmations: foldPendingConfirmations2 } = await import("./folding-NEZWWL7K.js");
-    const { createSessionStateMessage: createSessionStateMessage2 } = await import("./protocol-GG65P3FF.js");
+    const { createSessionStateMessage: createSessionStateMessage2 } = await import("./protocol-WHHYESPI.js");
     const eventStore = getEventStore2();
     const events = eventStore.getEvents(sessionId);
     const messages = buildMessagesFromStoredEvents2(events);
@@ -5814,7 +5385,7 @@ async function createServerHandle(config) {
     if (!callId || !answer) {
       return res.status(400).json({ error: "callId and answer are required" });
     }
-    const { provideAnswer: provideAnswer2 } = await import("./tools-DTNPLRKJ.js");
+    const { provideAnswer: provideAnswer2 } = await import("./tools-SJN7IGVF.js");
     const found = provideAnswer2(callId, answer);
     if (!found) {
       return res.status(404).json({ error: "No pending question with that ID" });
@@ -5850,8 +5421,8 @@ async function createServerHandle(config) {
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
-    const { stopSessionExecution } = await import("./chat-handler-UMXEBSMS.js");
-    const { cancelQuestionsForSession: cancelQuestionsForSession2, cancelPathConfirmationsForSession: cancelPathConfirmationsForSession2 } = await import("./tools-DTNPLRKJ.js");
+    const { stopSessionExecution } = await import("./chat-handler-DERM2S6L.js");
+    const { cancelQuestionsForSession: cancelQuestionsForSession2, cancelPathConfirmationsForSession: cancelPathConfirmationsForSession2 } = await import("./tools-SJN7IGVF.js");
     stopSessionExecution(sessionId, sessionManager);
     abortSession(sessionId);
     cancelQuestionsForSession2(sessionId, "Session stopped by user");
@@ -6310,7 +5881,7 @@ async function createServerHandle(config) {
     providerManager
   );
   const wss = wssExports.wss;
-  const { QueueProcessor } = await import("./processor-Q4NS4MID.js");
+  const { QueueProcessor } = await import("./processor-AS6JXF4U.js");
   const queueProcessor = new QueueProcessor({
     sessionManager,
     providerManager,
@@ -6383,4 +5954,4 @@ export {
   createServerHandle,
   createServer
 };
-//# sourceMappingURL=chunk-BMNBXLFY.js.map
+//# sourceMappingURL=chunk-JLMCJLTK.js.map