openfox 0.2.3 → 1.0.0

package/dist/{chunk-3WOUSUW7.js → chunk-RAZQTQK2.js}

@@ -1,126 +1,121 @@
 import {
-  AskUserInterrupt,
-  BUILDER_KICKOFF_PROMPT,
-  EventEmitter,
-  PathAccessDeniedError,
+  createVerifierNudgeConfig,
+  runBuilderTurn,
+  runChatTurn
+} from "./chunk-VZXXJKSQ.js";
+import {
   TurnMetrics,
   agentExists,
   assembleAgentRequest,
-  buildContextMessagesFromEventHistory,
-  buildMessagesFromStoredEvents,
-  buildSnapshotFromSessionState,
   cancelPathConfirmationsForSession,
-  cancelQuestionsForSession,
   createChatDoneEvent,
-  createChatDoneMessage,
-  createChatErrorMessage,
-  createChatMessageMessage,
-  createContextStateMessage,
-  createCriteriaUpdatedMessage,
-  createErrorMessage,
   createMessageStartEvent,
-  createModeChangedMessage,
-  createPhaseChangedMessage,
-  createProjectListMessage,
-  createProjectStateMessage,
-  createQueueStateMessage,
-  createSessionListMessage,
-  createSessionRunningMessage,
-  createSessionStateMessage,
-  createSettingsValueMessage,
   createToolRegistry,
   deleteAgent,
   deleteSkill,
   devServerManager,
-  emitAssistantMessageStart,
-  emitContextCompacted,
-  emitContextState,
-  emitCriteriaSet,
-  emitCriterionUpdated,
-  emitModeChanged,
-  emitPhaseChanged,
-  emitRunningChanged,
-  emitSessionInitialized,
-  emitUserMessage,
   ensureDefaultAgents,
   ensureDefaultSkills,
   executeSubAgent,
   findAgentById,
   findSkillById,
-  getCurrentContextWindowId,
+  getAllInstructions,
   getDefaultAgentIds,
   getDefaultSkillIds,
-  getEventStore,
+  getEnabledSkillMetadata,
   getModifiedDefaultAgentIds,
   getModifiedDefaultSkillIds,
-  getRecentUserPromptsForSession,
-  getRuntimeConfig,
-  getSessionState,
-  getSubAgents,
   getToolRegistryForAgent,
-  initEventStore,
-  isChatSendPayload,
-  isCriteriaEditPayload,
-  isModeSwitchPayload,
-  isPathConfirmPayload,
-  isProjectCreatePayload,
-  isProjectCreateWithDirPayload,
-  isProjectDeletePayload,
-  isProjectLoadPayload,
-  isProjectUpdatePayload,
-  isQueueAsapPayload,
-  isQueueCancelPayload,
-  isQueueCompletionPayload,
-  isSessionCreatePayload,
-  isSessionLoadPayload,
-  isSessionSetProviderPayload,
-  isSettingsGetPayload,
-  isSettingsSetPayload,
   isSkillEnabled,
   loadAllAgents,
   loadAllAgentsDefault,
   loadAllSkills,
   maybeAutoCompactContext,
-  parseClientMessage,
   performManualContextCompaction,
-  providePathConfirmation,
   restoreAllDefaultAgents,
   restoreAllDefaultSkills,
   restoreDefaultAgent,
   restoreDefaultSkill,
-  runTopLevelAgentLoop,
   saveAgent,
   saveSkill,
-  serializeServerMessage,
-  setRuntimeConfig,
   setSkillEnabled,
-  skillExists,
+  skillExists
+} from "./chunk-YB2574C6.js";
+import {
+  generateSessionName,
+  needsNameGeneration
+} from "./chunk-QDEKU5RL.js";
+import {
+  createProviderManager,
+  parseDefaultModelSelection
+} from "./chunk-QYP5HQV4.js";
+import {
+  createSession,
+  deleteSession,
+  emitAssistantMessageStart,
+  emitContextCompacted,
+  emitContextState,
+  emitCriteriaSet,
+  emitCriterionUpdated,
+  emitModeChanged,
+  emitPhaseChanged,
+  emitRunningChanged,
+  emitSessionInitialized,
+  emitUserMessage,
+  getCurrentContextWindowId,
+  getEventStore,
+  getSession,
+  getSessionState,
+  initEventStore,
+  listSessions,
+  listSessionsByProject,
+  updateSessionDangerLevel,
+  updateSessionMetadata,
+  updateSessionProvider,
+  updateSessionSummary
+} from "./chunk-BU2ZYOEA.js";
+import {
+  buildContextMessagesFromEventHistory,
+  buildMessagesFromStoredEvents,
+  foldPendingConfirmations
+} from "./chunk-2KSCZSXQ.js";
+import {
+  createChatErrorMessage,
+  createChatMessageMessage,
+  createContextStateMessage,
+  createErrorMessage,
+  createPhaseChangedMessage,
+  createQueueStateMessage,
+  createSessionRunningMessage,
+  createSessionStateMessage,
+  isAskAnswerPayload,
+  isChatSendPayload,
+  isSessionLoadPayload,
+  parseClientMessage,
+  serializeServerMessage,
   storedEventToServerMessage
-} from "./chunk-FUUYYDVG.js";
+} from "./chunk-S4QKTRGJ.js";
 import {
-  getSetting,
-  setSetting
-} from "./chunk-MTX5Y3V3.js";
+  EventEmitter,
+  cancelQuestionsForSession,
+  provideAnswer
+} from "./chunk-22CTURMH.js";
 import {
-  createProject,
-  deleteProject,
-  getProject,
-  listProjects,
-  updateProject
-} from "./chunk-N2XYX4ZA.js";
+  getProject
+} from "./chunk-XKFPU2FA.js";
 import {
-  getDatabase,
   initDatabase
-} from "./chunk-4Z2OZ6NX.js";
+} from "./chunk-3EHGGBWE.js";
 import {
   computeSessionStats
 } from "./chunk-QY7BMXWT.js";
 import {
   createServerMessage
-} from "./chunk-ARFK3RZW.js";
+} from "./chunk-TPT6HP4H.js";
 import {
-  createProviderManager
-} from "./chunk-L4XDA3V7.js";
+  getRuntimeConfig,
+  setRuntimeConfig
+} from "./chunk-TVQOONDR.js";
 import {
   SessionNotFoundError,
   createLLMClient,
@@ -129,14 +124,14 @@ import {
   getBackendDisplayName,
   getLlmStatus,
   getModelProfile
-} from "./chunk-5ZUU23XF.js";
+} from "./chunk-U6BUT37A.js";
+import {
+  getGlobalConfigDir
+} from "./chunk-5YQAXUKO.js";
 import {
   logger,
   setLogLevel
-} from "./chunk-U62ZECSQ.js";
-import {
-  getGlobalConfigDir
-} from "./chunk-AF7XS4OI.js";
+} from "./chunk-PNBH3RAX.js";
 
 // src/server/index.ts
 import express from "express";
@@ -157,92 +152,157 @@ var RULES = [
   {
     match: /ID\s*["']([a-z0-9-]+)["']:\s*["']([^"']+)["'][\s\S]*ID\s*["']([a-z0-9-]+)["']:\s*["']([^"']+)["']/i,
     tools: [
-      { name: "add_criterion", arguments: { id: "$1", description: "$2" } },
-      { name: "add_criterion", arguments: { id: "$3", description: "$4" } }
+      { name: "criterion", arguments: { action: "add", id: "$1", description: "$2" } },
+      { name: "criterion", arguments: { action: "add", id: "$3", description: "$4" } }
     ],
     response: "Added both criteria."
   },
+  // Single criterion: "Add criterion ID "test-1" with description "The tests pass""
+  {
+    match: /Add criterion ID\s*["']([a-z0-9-]+)["']\s*with description\s*["']([^"']+)["'][\s\S]*/i,
+    tools: [{ name: "criterion", arguments: { action: "add", id: "$1", description: "$2" } }],
+    response: "Added the criterion."
+  },
   // Single criterion: ID "test-1" with/: description "The tests pass"
   {
     match: /ID\s*["']([a-z0-9-]+)["'].*description\s*["']([^"']+)["']/i,
-    tools: [{ name: "add_criterion", arguments: { id: "$1", description: "$2" } }],
+    tools: [{ name: "criterion", arguments: { action: "add", id: "$1", description: "$2" } }],
     response: "Added the criterion."
   },
   {
-    match: /Add these two acceptance criteria:\s*1\.\s*([^\n]+)\s*2\.\s*([^\n]+)\s*Use add_criterion for each\./i,
+    match: /Add these two acceptance criteria:\s*1\.\s*([^\n]+)\s*2\.\s*([^\n]+)\s*Use criterion for each\./i,
     tools: [
-      { name: "add_criterion", arguments: { id: "criterion-1", description: "$1" } },
-      { name: "add_criterion", arguments: { id: "criterion-2", description: "$2" } }
+      { name: "criterion", arguments: { action: "add", id: "criterion-1", description: "$1" } },
+      { name: "criterion", arguments: { action: "add", id: "criterion-2", description: "$2" } }
     ],
     response: "Added both criteria."
   },
   {
-    match: /Add these two acceptance criteria:[\s\S]*?1\.\s*([^\n]+)[\s\S]*?2\.\s*([^\n]+)[\s\S]*?Use add_criterion for each one\./i,
+    match: /Add these two acceptance criteria:[\s\S]*?1\.\s*([^\n]+)[\s\S]*?2\.\s*([^\n]+)[\s\S]*?Use (?:add_)?criterion for each one\./i,
     tools: [
-      { name: "add_criterion", arguments: { id: "criterion-1", description: "$1" } },
-      { name: "add_criterion", arguments: { id: "criterion-2", description: "$2" } }
+      { name: "criterion", arguments: { action: "add", id: "criterion-1", description: "$1" } },
+      { name: "criterion", arguments: { action: "add", id: "criterion-2", description: "$2" } }
     ],
     response: "Added both criteria."
   },
   {
-    match: /Add criterion:\s*([\s\S]+?)\s*Use add_criterion\.?/i,
-    tools: [{ name: "add_criterion", arguments: { id: "$auto", description: "$1" } }],
+    match: /Add these two acceptance criteria:[\s\S]*?1\.\s*([^\n]+)[\s\S]*?2\.\s*([^\n]+)/i,
+    tools: [
+      { name: "criterion", arguments: { action: "add", id: "criterion-1", description: "$1" } },
+      { name: "criterion", arguments: { action: "add", id: "criterion-2", description: "$2" } }
+    ],
+    response: "Added both criteria."
+  },
+  {
+    match: /Add criterion:\s*([\s\S]+?)\s*Use criterion\.?/i,
+    tools: [{ name: "criterion", arguments: { action: "add", id: "$auto", description: "$1" } }],
     response: "Added the criterion."
   },
   // Single criterion: ID "test-1": "The tests pass" (colon format)
   {
     match: /ID\s*["']([a-z0-9-]+)["']\s*:\s*["']([^"']+)["']/i,
-    tools: [{ name: "add_criterion", arguments: { id: "$1", description: "$2" } }],
+    tools: [{ name: "criterion", arguments: { action: "add", id: "$1", description: "$2" } }],
     response: "Added the criterion."
   },
   // complete_criterion to mark "id" as done
   {
     match: /complete_criterion.*mark\s*["']([a-z0-9-]+)["']/i,
-    tools: [{ name: "complete_criterion", arguments: { id: "$1", reason: "Completed successfully" } }],
+    tools: [{ name: "criterion", arguments: { action: "complete", id: "$1", reason: "Completed successfully" } }],
     response: "Marked criterion as complete."
   },
   // complete_criterion with ID
   {
     match: /complete_criterion.*["']([a-z0-9-]+)["']/i,
-    tools: [{ name: "complete_criterion", arguments: { id: "$1", reason: "Completed successfully" } }],
+    tools: [{ name: "criterion", arguments: { action: "complete", id: "$1", reason: "Completed successfully" } }],
+    response: "Marked criterion as complete."
+  },
+  // criterion with action "complete" for "id"
+  {
+    match: /criterion.*action\s*["']complete["'].*["']([a-z0-9-]+)["']/i,
+    tools: [{ name: "criterion", arguments: { action: "complete", id: "$1", reason: "Completed successfully" } }],
     response: "Marked criterion as complete."
   },
   // remove_criterion to remove "id"
   {
     match: /remove_criterion.*remove\s*["']([a-z0-9-]+)["']/i,
-    tools: [{ name: "remove_criterion", arguments: { id: "$1" } }],
+    tools: [{ name: "criterion", arguments: { action: "remove", id: "$1" } }],
     response: "Removed the criterion."
   },
   // remove_criterion with ID
   {
     match: /remove_criterion.*["']([a-z0-9-]+)["']/i,
-    tools: [{ name: "remove_criterion", arguments: { id: "$1" } }],
+    tools: [{ name: "criterion", arguments: { action: "remove", id: "$1" } }],
     response: "Removed the criterion."
   },
   // update_criterion to change "id" description to "new"
   {
     match: /update_criterion.*change\s*["']([a-z0-9-]+)["'].*to\s*["']([^"']+)["']/i,
-    tools: [{ name: "update_criterion", arguments: { id: "$1", description: "$2" } }],
+    tools: [{ name: "criterion", arguments: { action: "update", id: "$1", description: "$2" } }],
     response: "Updated the criterion."
   },
   // update_criterion with ID and description
   {
     match: /update_criterion.*["']([a-z0-9-]+)["'].*["']([^"']+)["']/i,
-    tools: [{ name: "update_criterion", arguments: { id: "$1", description: "$2" } }],
+    tools: [{ name: "criterion", arguments: { action: "update", id: "$1", description: "$2" } }],
     response: "Updated the criterion."
   },
   // get_criteria
   {
-    match: /get_criteria/i,
-    tools: [{ name: "get_criteria", arguments: {} }],
+    match: /get_criteria|show.*criteria|list.*criteria/i,
+    tools: [{ name: "criterion", arguments: { action: "get" } }],
     response: "Here are the current criteria."
   },
+  // pass_criterion
+  {
+    match: /pass_criterion.*["']([a-z0-9-]+)["']/i,
+    tools: [{ name: "criterion", arguments: { action: "pass", id: "$1", reason: "Verified successfully" } }],
+    response: "Criterion passed."
+  },
+  // fail_criterion
+  {
+    match: /fail_criterion.*["']([a-z0-9-]+)["']/i,
+    tools: [{ name: "criterion", arguments: { action: "fail", id: "$1", reason: "Verification failed" } }],
+    response: "Criterion failed."
+  },
   // Generic add criterion (fallback)
   {
     match: /add.*criterion/i,
-    tools: [{ name: "add_criterion", arguments: { id: "$auto", description: "Test criterion" } }],
+    tools: [{ name: "criterion", arguments: { action: "add", description: "Test criterion" } }],
     response: "Added the criterion."
   },
+  // Verifier nudge with fail criterion (check for "fail" in ID) - MUST come before general pass rule
+  {
+    match: /Use criterion with action ["']pass["'] or ["']fail["'].*criterion.*:\s*([a-z0-9-]*fail[a-z0-9-]*)/i,
+    tools: [{ name: "criterion", arguments: { action: "fail", id: "$1", reason: "Verification failed" } }],
+    response: "Criterion failed."
+  },
+  // Verifier nudge: Use criterion with action "pass" or "fail" for criterion-id-1, criterion-id-2
+  {
+    match: /Use criterion with action ["']pass["'] or ["']fail["'].*criterion:\s*([a-z0-9-]+)/i,
+    tools: [{ name: "criterion", arguments: { action: "pass", id: "$1", reason: "Verified successfully" } }],
+    response: "Criterion passed."
+  },
+  // Verifier nudge with multiple criteria
+  {
+    match: /Use criterion with action ["']pass["'] or ["']fail["'].*criterion:\s*([a-z0-9-]+),\s*([a-z0-9-]+)/i,
+    tools: [
+      { name: "criterion", arguments: { action: "pass", id: "$1", reason: "Verified successfully" } },
+      { name: "criterion", arguments: { action: "pass", id: "$2", reason: "Verified successfully" } }
+    ],
+    response: "Criteria passed."
+  },
+  // Verifier should fail a criterion
+  {
+    match: /Verifier should fail.*criterion.*ID\s*["']([a-z0-9-]+)["']/i,
+    tools: [{ name: "criterion", arguments: { action: "fail", id: "$1", reason: "Verification failed" } }],
+    response: "Criterion failed."
+  },
+  // Verifier fail_criterion command
+  {
+    match: /fail_criterion.*ID\s*["']([a-z0-9-]+)["']/i,
+    tools: [{ name: "criterion", arguments: { action: "fail", id: "$1", reason: "Verification failed" } }],
+    response: "Criterion failed."
+  },
   // -------------------------------------------------------------------------
   // File Read Tools
   // -------------------------------------------------------------------------
@@ -533,11 +593,12 @@ var RULES = [
   {
     match: /todo_write.*Read files.*Make changes/i,
     tools: [{
-      name: "todo_write",
+      name: "todo",
       arguments: {
+        action: "write",
         todos: [
-          { content: "Read files", status: "in_progress", priority: "high" },
-          { content: "Make changes", status: "pending", priority: "medium" }
+          { content: "Read files", status: "in_progress" },
+          { content: "Make changes", status: "pending" }
         ]
       }
     }],
@@ -546,9 +607,10 @@ var RULES = [
   {
     match: /todo_write|todo.*list/i,
     tools: [{
-      name: "todo_write",
+      name: "todo",
       arguments: {
-        todos: [{ content: "Test task", status: "pending", priority: "medium" }]
+        action: "write",
+        todos: [{ content: "Test task", status: "pending" }]
       }
     }],
     response: "Created todo list."
@@ -567,6 +629,19 @@ var RULES = [
     response: "Here is a detailed explanation of the topic. TypeScript is a statically typed superset of JavaScript that adds optional type annotations. It provides better tooling, catches errors at compile time, and makes code more maintainable."
   },
   // -------------------------------------------------------------------------
+  // Ask User Tool
+  // -------------------------------------------------------------------------
+  {
+    match: /ask.*user|ask.*question|clarif/i,
+    tools: [{ name: "ask_user", arguments: { question: "What would you like me to do?" } }],
+    response: "I asked the user."
+  },
+  {
+    match: /confirm.*with.*user/i,
+    tools: [{ name: "ask_user", arguments: { question: "Should I proceed with this action?" } }],
+    response: "I asked for confirmation."
+  },
+  // -------------------------------------------------------------------------
   // Default Responses (no tools)
   // -------------------------------------------------------------------------
   {
@@ -737,11 +812,12 @@ function getPromptAwareToolResponse(prompt) {
   if (/Use the todo_write tool to create a todo list with 2 items/i.test(prompt)) {
     return {
       tools: [{
-        name: "todo_write",
+        name: "todo",
         arguments: {
+          action: "write",
           todos: [
-            { content: "Read files", status: "in_progress", priority: "high" },
-            { content: "Make changes", status: "pending", priority: "medium" }
+            { content: "Read files", status: "in_progress" },
+            { content: "Make changes", status: "pending" }
           ]
         }
       }],
@@ -751,9 +827,9 @@ function getPromptAwareToolResponse(prompt) {
   if (/First call get_criteria to see what needs to be done, then create src\/test\.ts and call complete_criterion for ["']test-file["']\./i.test(prompt)) {
     return {
       tools: [
-        { name: "get_criteria", arguments: {} },
+        { name: "criterion", arguments: { action: "get" } },
         { name: "write_file", arguments: { path: "src/test.ts", content: "export const created = true" } },
-        { name: "complete_criterion", arguments: { id: "test-file", reason: "Created the requested file" } },
+        { name: "criterion", arguments: { action: "complete", id: "test-file", reason: "Created the requested file" } },
         { name: "step_done", arguments: {} }
       ],
       response: "Reviewed the criteria, created the file, and completed the criterion."
@@ -763,7 +839,7 @@ function getPromptAwareToolResponse(prompt) {
     return {
       tools: [
         { name: "write_file", arguments: { path: "src/utils.ts", content: "export const created = true" } },
-        { name: "complete_criterion", arguments: { id: "file-created", reason: "Created the requested file" } },
+        { name: "criterion", arguments: { action: "complete", id: "file-created", reason: "Created the requested file" } },
         { name: "step_done", arguments: {} }
       ],
       response: "Created the file and completed the criterion."
@@ -852,27 +928,27 @@ function getConversationAwareToolResponse(request) {
     if (conversationText.includes("inspect-src")) {
       tools.push(
         { name: "read_file", arguments: { path: "src" } },
-        { name: "complete_criterion", arguments: { id: "inspect-src", reason: "Inspected the src directory and reported what exists" } }
+        { name: "criterion", arguments: { action: "complete", id: "inspect-src", reason: "Inspected the src directory and reported what exists" } }
       );
       completedCriteria.push("inspect-src");
     }
     if (conversationText.includes("trivial-pass")) {
-      tools.push({ name: "complete_criterion", arguments: { id: "trivial-pass", reason: "Trivial criterion passes immediately" } });
+      tools.push({ name: "criterion", arguments: { action: "complete", id: "trivial-pass", reason: "Trivial criterion passes immediately" } });
       completedCriteria.push("trivial-pass");
     }
     if (conversationText.includes("verify-fail")) {
-      tools.push({ name: "complete_criterion", arguments: { id: "verify-fail", reason: "Prepared criterion for verification" } });
+      tools.push({ name: "criterion", arguments: { action: "complete", id: "verify-fail", reason: "Prepared criterion for verification" } });
       completedCriteria.push("verify-fail");
     }
     if (conversationText.includes("file-created")) {
       tools.push(
         { name: "write_file", arguments: { path: "src/utils.ts", content: "export const created = true" } },
-        { name: "complete_criterion", arguments: { id: "file-created", reason: "Created the requested file" } }
+        { name: "criterion", arguments: { action: "complete", id: "file-created", reason: "Created the requested file" } }
       );
       completedCriteria.push("file-created");
     }
     if (tools.length === 0) {
-      tools.push({ name: "complete_criterion", arguments: { id: "mock-crit", reason: "Completed for testing" } });
+      tools.push({ name: "criterion", arguments: { action: "complete", id: "mock-crit", reason: "Completed for testing" } });
       completedCriteria.push("mock-crit");
     }
     tools.push({ name: "step_done", arguments: {} });
@@ -884,7 +960,7 @@ function getConversationAwareToolResponse(request) {
   if (/fulfil the \d+ criteria/i.test(prompt)) {
     return {
       tools: [
-        { name: "complete_criterion", arguments: { id: "mock-crit", reason: "Completed for testing" } },
+        { name: "criterion", arguments: { action: "complete", id: "mock-crit", reason: "Completed for testing" } },
         { name: "step_done", arguments: {} }
       ],
       response: "Completed criterion and finished step."
@@ -895,17 +971,17 @@ function getConversationAwareToolResponse(request) {
     if (conversationText.includes("file-created")) {
       tools.push(
         { name: "write_file", arguments: { path: "src/utils.ts", content: "export const created = true" } },
-        { name: "complete_criterion", arguments: { id: "file-created", reason: "Created the requested file" } }
+        { name: "criterion", arguments: { action: "complete", id: "file-created", reason: "Created the requested file" } }
       );
     } else if (conversationText.includes("trivial-pass")) {
-      tools.push({ name: "complete_criterion", arguments: { id: "trivial-pass", reason: "Trivial criterion passes immediately" } });
+      tools.push({ name: "criterion", arguments: { action: "complete", id: "trivial-pass", reason: "Trivial criterion passes immediately" } });
     } else if (conversationText.includes("verify-fail")) {
-      tools.push({ name: "complete_criterion", arguments: { id: "verify-fail", reason: "Prepared criterion for verification" } });
+      tools.push({ name: "criterion", arguments: { action: "complete", id: "verify-fail", reason: "Prepared criterion for verification" } });
     } else {
       if (/1 criteria remaining/i.test(prompt)) {
-        tools.push({ name: "complete_criterion", arguments: { id: "trivial-pass", reason: "Trivial criterion passes immediately" } });
+        tools.push({ name: "criterion", arguments: { action: "complete", id: "trivial-pass", reason: "Trivial criterion passes immediately" } });
       } else {
-        tools.push({ name: "complete_criterion", arguments: { id: "mock-crit", reason: "Completed for testing" } });
+        tools.push({ name: "criterion", arguments: { action: "complete", id: "mock-crit", reason: "Completed for testing" } });
       }
     }
     tools.push({ name: "step_done", arguments: {} });
@@ -917,7 +993,7 @@ function getConversationAwareToolResponse(request) {
   if (/Verify each criterion marked \[NEEDS VERIFICATION\]\./i.test(prompt)) {
     const alreadyVerified = request.messages.some(
       (m) => m.role === "assistant" && m.toolCalls?.some(
-        (tc) => tc.name === "pass_criterion" || tc.name === "fail_criterion"
+        (tc) => tc.name === "criterion" && (tc.arguments["action"] === "pass" || tc.arguments["action"] === "fail")
       )
     );
     if (alreadyVerified) {
@@ -926,23 +1002,23 @@ function getConversationAwareToolResponse(request) {
     const tools = [];
     const terminalizedCriteria = [];
     if (conversationText.includes("trivial-pass")) {
-      tools.push({ name: "pass_criterion", arguments: { id: "trivial-pass", reason: "Verified successfully" } });
+      tools.push({ name: "criterion", arguments: { action: "pass", id: "trivial-pass", reason: "Verified successfully" } });
       terminalizedCriteria.push("trivial-pass");
     }
     if (conversationText.includes("inspect-src")) {
-      tools.push({ name: "pass_criterion", arguments: { id: "inspect-src", reason: "Verified the src directory was inspected successfully" } });
+      tools.push({ name: "criterion", arguments: { action: "pass", id: "inspect-src", reason: "Verified the src directory was inspected successfully" } });
       terminalizedCriteria.push("inspect-src");
     }
     if (conversationText.includes("verify-fail")) {
-      tools.push({ name: "fail_criterion", arguments: { id: "verify-fail", reason: "Verification fails intentionally for this criterion" } });
+      tools.push({ name: "criterion", arguments: { action: "complete", id: "verify-fail", reason: "Verification fails intentionally for this criterion" } });
       terminalizedCriteria.push("verify-fail");
     }
     if (conversationText.includes("file-created")) {
-      tools.push({ name: "pass_criterion", arguments: { id: "file-created", reason: "Verified the file was created successfully" } });
+      tools.push({ name: "criterion", arguments: { action: "pass", id: "file-created", reason: "Verified the file was created successfully" } });
       terminalizedCriteria.push("file-created");
     }
     if (conversationText.includes("impossible/path")) {
-      tools.push({ name: "fail_criterion", arguments: { id: "auto-impossible", reason: "Impossible path does not exist" } });
+      tools.push({ name: "criterion", arguments: { action: "complete", id: "auto-impossible", reason: "Impossible path does not exist" } });
       terminalizedCriteria.push("auto-impossible");
     }
     if (tools.length > 0) {
@@ -1101,211 +1177,189 @@ function createMockLLMClient() {
 }
 
 // src/server/ws/server.ts
-import { WebSocketServer, WebSocket } from "ws";
+import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
 
-// src/server/sub-agents/verifier-helpers.ts
-var MAX_CONSECUTIVE_VERIFIER_NUDGES = 10;
-var VERIFIER_STALL_REASON = "Verifier stopped repeatedly before terminalizing verification after repeated nudges.";
-function getCriteriaAwaitingVerification(criteria) {
-  return criteria.filter((criterion) => criterion.status.type === "completed");
-}
-function buildVerifierNudgeContent(criteria) {
-  const ids = criteria.map((criterion) => criterion.id).join(", ");
-  return `You stopped before finalizing verification. ${criteria.length} criteria still need a terminal verification result. Use pass_criterion or fail_criterion for each remaining criterion: ${ids}.`;
-}
-function buildVerifierRestartContent(criteria) {
-  const ids = criteria.map((criterion) => criterion.id).join(", ");
-  return `${VERIFIER_STALL_REASON} Leaving remaining criteria unchanged so verification can restart in a fresh window: ${ids}.`;
-}
-function createVerifierNudgeConfig() {
-  return {
-    maxConsecutiveNudges: MAX_CONSECUTIVE_VERIFIER_NUDGES,
-    getCriteriaAwaiting: getCriteriaAwaitingVerification,
-    buildNudgeContent: buildVerifierNudgeContent,
-    buildRestartContent: buildVerifierRestartContent
-  };
-}
+// src/server/ws/terminal.ts
+import WebSocket from "ws";
 
-// src/server/chat/orchestrator.ts
-function getCurrentWindowMessageOptions(sessionId) {
-  const contextWindowId = getCurrentContextWindowId(sessionId);
-  return contextWindowId ? { contextWindowId } : void 0;
-}
-function resolveStatsIdentity(options) {
-  const model = options.llmClient.getModel();
-  if (options.statsIdentity) {
-    return {
-      ...options.statsIdentity,
-      model
+// src/server/terminal/manager.ts
+import * as pty from "node-pty";
+import os from "os";
+var TerminalManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  outputCallbacks = /* @__PURE__ */ new Set();
+  outputHistory = /* @__PURE__ */ new Map();
+  generateId() {
+    return `term_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+  getShell() {
+    const shell = process.env["SHELL"] || "/bin/bash";
+    return shell;
+  }
+  resolveWorkdir(workdir) {
+    if (workdir && workdir.length > 0) {
+      return workdir;
+    }
+    return os.homedir();
+  }
+  create(workdir) {
+    const id = this.generateId();
+    const shell = this.getShell();
+    const cwd = this.resolveWorkdir(workdir);
+    const ptyProcess = pty.spawn(shell, [], {
+      name: "xterm-256color",
+      cols: 80,
+      rows: 24,
+      cwd,
+      env: process.env
+    });
+    const session = {
+      id,
+      pty: ptyProcess,
+      workdir: cwd
     };
+    ptyProcess.onData((data) => {
+      const output = { sessionId: id, data };
+      for (const cb of this.outputCallbacks) {
+        cb(output);
+      }
+      const history = this.outputHistory.get(id) || [];
+      history.push(data);
+      if (history.length > 1e4) history.shift();
+      this.outputHistory.set(id, history);
+    });
+    this.sessions.set(id, session);
+    logger.info("Terminal session created", { id, shell, cwd });
+    return session;
   }
-  return {
-    providerId: `provider:${model}`,
-    providerName: "Unknown Provider",
-    backend: "unknown",
-    model
-  };
-}
-async function runChatTurn(options) {
-  const { sessionManager: sessionManager2, sessionId } = options;
-  const eventStore = getEventStore();
-  const statsIdentity = resolveStatsIdentity(options);
-  const session = sessionManager2.requireSession(sessionId);
-  const mode = session.mode;
-  logger.debug("Starting chat turn", { sessionId, mode });
-  const turnMetrics = new TurnMetrics();
-  try {
-    if (mode === "builder") {
-      await runBuilderTurn(options, turnMetrics);
-    } else {
-      await runGenericAgentTurn(options, turnMetrics, mode);
-    }
-    const snapshot = buildSnapshot(sessionManager2, sessionId, turnMetrics.buildStats(statsIdentity, mode));
-    const snapshotEvent = eventStore.append(sessionId, { type: "turn.snapshot", data: snapshot });
-    const deletedCount = eventStore.cleanupOldEvents(sessionId);
-    if (deletedCount > 0) {
-      logger.debug("Cleaned up old events after snapshot", { sessionId, deletedCount, snapshotSeq: snapshotEvent.seq });
+  write(sessionId, data) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return false;
     }
-  } catch (error) {
-    if (error instanceof AskUserInterrupt) {
-      const waitMsgId = crypto.randomUUID();
-      eventStore.append(sessionId, createMessageStartEvent(waitMsgId, "user", "Waiting for user input...", {
-        ...getCurrentWindowMessageOptions(sessionId) ?? {},
-        isSystemGenerated: true,
-        messageKind: "auto-prompt"
-      }));
-      eventStore.append(sessionId, createChatDoneEvent(waitMsgId, "waiting_for_user"));
-      return;
+    session.pty.write(data);
+    return true;
+  }
+  resize(sessionId, cols, rows) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return false;
     }
-    if (error instanceof PathAccessDeniedError) {
-      const errorMsgId2 = crypto.randomUUID();
-      const reasonText = error.reason === "sensitive_file" ? "sensitive files that may contain secrets" : error.reason === "both" ? "files outside the project and sensitive files" : "files outside the project directory";
-      eventStore.append(sessionId, {
-        type: "chat.error",
-        data: {
-          error: `User denied access to ${reasonText}.`,
-          recoverable: false
-        }
-      });
-      eventStore.append(sessionId, createMessageStartEvent(errorMsgId2, "user", `Access denied: ${error.paths.join(", ")}. If you need this file, explain why and ask the user for permission.`, {
-        ...getCurrentWindowMessageOptions(sessionId) ?? {},
-        isSystemGenerated: true,
-        messageKind: "correction"
-      }));
-      eventStore.append(sessionId, createChatDoneEvent(errorMsgId2, "error"));
-      return;
+    session.pty.resize(cols, rows);
+    return true;
+  }
+  kill(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return false;
     }
-    if (error instanceof Error && error.message === "Aborted") {
-      return;
+    session.pty.kill();
+    this.sessions.delete(sessionId);
+    logger.info("Terminal session killed", { id: sessionId });
+    return true;
+  }
+  get(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  getAll() {
+    return Array.from(this.sessions.values());
+  }
+  getOutputHistory(sessionId) {
+    return (this.outputHistory.get(sessionId) || []).join("");
+  }
+  onOutput(callback) {
+    this.outputCallbacks.add(callback);
+    return () => {
+      this.outputCallbacks.delete(callback);
+    };
+  }
+  killAll() {
+    for (const session of this.sessions.values()) {
+      session.pty.kill();
     }
-    logger.error("Chat turn error", { sessionId, mode, error });
-    const errorMsgId = crypto.randomUUID();
-    eventStore.append(sessionId, {
-      type: "chat.error",
-      data: {
-        error: error instanceof Error ? error.message : "Unknown error",
-        recoverable: false
-      }
-    });
-    eventStore.append(sessionId, createMessageStartEvent(errorMsgId, "user", `Error: ${error instanceof Error ? error.message : "Unknown error"}`, {
-      ...getCurrentWindowMessageOptions(sessionId) ?? {},
-      isSystemGenerated: true,
-      messageKind: "correction"
-    }));
-    eventStore.append(sessionId, createChatDoneEvent(errorMsgId, "error"));
-  } finally {
-    eventStore.append(sessionId, { type: "running.changed", data: { isRunning: false } });
+    this.sessions.clear();
+    logger.info("All terminal sessions killed");
   }
+};
+var terminalManager = new TerminalManager();
+
+// src/server/ws/terminal.ts
+var subscriptions = /* @__PURE__ */ new Set();
+var outputHandlerRegistered = false;
+function registerOutputHandler() {
+  if (outputHandlerRegistered) return;
+  outputHandlerRegistered = true;
+  terminalManager.onOutput((output) => {
+    const subs = Array.from(subscriptions).filter(
+      (s) => s.sessionId === output.sessionId && s.ws.readyState === WebSocket.OPEN
+    );
+    for (const sub of subs) {
+      sub.ws.send(JSON.stringify({
+        type: "terminal.output",
+        payload: { sessionId: output.sessionId, data: output.data }
+      }));
+    }
+  });
 }
-async function runGenericAgentTurn(options, turnMetrics, agentId) {
-  const statsIdentity = resolveStatsIdentity(options);
-  const allAgents = await loadAllAgentsDefault();
-  const agentDef = findAgentById(agentId, allAgents) ?? findAgentById("planner", allAgents);
-  const subAgentDefs = getSubAgents(allAgents);
-  await runTopLevelAgentLoop({
-    mode: agentId,
-    sessionManager: options.sessionManager,
-    sessionId: options.sessionId,
-    llmClient: options.llmClient,
-    statsIdentity,
-    signal: options.signal,
-    onMessage: options.onMessage,
-    assembleRequest: (input) => assembleAgentRequest({ ...input, agentDef, subAgentDefs }),
-    getToolRegistry: () => getToolRegistryForAgent(agentDef)
-  }, turnMetrics);
-}
-async function runBuilderTurn(options, turnMetrics) {
-  const { sessionManager: sessionManager2, sessionId } = options;
-  const statsIdentity = resolveStatsIdentity(options);
-  const eventStore = getEventStore();
-  const allAgents = await loadAllAgentsDefault();
-  const builderDef = findAgentById("builder", allAgents);
-  const subAgentDefs = getSubAgents(allAgents);
-  let stepDoneCalled = false;
-  return {
-    ...await runTopLevelAgentLoop({
-      mode: "builder",
-      sessionManager: sessionManager2,
-      sessionId,
-      llmClient: options.llmClient,
-      statsIdentity,
-      signal: options.signal,
-      onMessage: options.onMessage,
-      assembleRequest: (input) => assembleAgentRequest({ ...input, agentDef: builderDef, subAgentDefs }),
-      getToolRegistry: () => {
-        const baseRegistry = getToolRegistryForAgent(builderDef);
-        if (options.injectStepDone === true) {
-          return baseRegistry;
-        }
-        return {
-          tools: baseRegistry.tools.filter((t) => t.name !== "step_done"),
-          definitions: baseRegistry.definitions.filter((d) => d.type === "function" && d.function.name !== "step_done"),
-          execute: baseRegistry.execute
-        };
-      },
-      onToolExecuted: (toolCall, toolResult) => {
-        if (toolCall.name === "step_done" && toolResult.success) {
-          stepDoneCalled = true;
+function handleTerminalMessage(ws, message) {
+  switch (message.type) {
+    case "terminal.subscribe": {
+      if (message.payload.sessionId) {
+        const exists = Array.from(subscriptions).some(
+          (sub) => sub.ws === ws && sub.sessionId === message.payload.sessionId
+        );
+        if (!exists) {
+          subscriptions.add({ ws, sessionId: message.payload.sessionId });
         }
-        if (toolResult.success && ["write_file", "edit_file"].includes(toolCall.name)) {
-          const path = toolCall.arguments["path"];
-          sessionManager2.addModifiedFile(sessionId, path);
+        registerOutputHandler();
+        const sessionId = message.payload.sessionId;
+        const history = terminalManager.getOutputHistory(sessionId);
+        if (history) {
+          setTimeout(() => {
+            ws.send(JSON.stringify({
+              type: "terminal.output",
+              payload: { sessionId, data: history }
+            }));
+          }, 100);
         }
-      },
-      injectKickoff: () => {
-        if (options.injectBuilderKickoff !== true) return;
-        const session = sessionManager2.requireSession(sessionId);
-        const events = eventStore.getEvents(sessionId);
-        const hasBuilderKickoff = events.some((e) => {
-          if (e.type !== "message.start") return false;
-          const data = e.data;
-          return data.messageKind === "auto-prompt" && data.content?.includes("fulfil the");
-        });
-        if (!hasBuilderKickoff) {
-          const kickoffMsgId = crypto.randomUUID();
-          const kickoffContent = BUILDER_KICKOFF_PROMPT(session.criteria.length);
-          eventStore.append(sessionId, createMessageStartEvent(kickoffMsgId, "user", kickoffContent, {
-            ...getCurrentWindowMessageOptions(sessionId) ?? {},
-            isSystemGenerated: true,
-            messageKind: "auto-prompt"
-          }));
-          eventStore.append(sessionId, { type: "message.done", data: { messageId: kickoffMsgId } });
+      }
+      break;
+    }
+    case "terminal.write": {
+      if (message.payload.sessionId && message.payload.data) {
+        terminalManager.write(message.payload.sessionId, message.payload.data);
+      }
+      break;
+    }
+    case "terminal.resize": {
+      if (message.payload.sessionId && typeof message.payload.cols === "number" && typeof message.payload.rows === "number") {
+        terminalManager.resize(message.payload.sessionId, message.payload.cols, message.payload.rows);
+      }
+      break;
+    }
+    case "terminal.kill": {
+      if (message.payload.sessionId) {
+        terminalManager.kill(message.payload.sessionId);
+        for (const sub of subscriptions) {
+          if (sub.sessionId === message.payload.sessionId) {
+            subscriptions.delete(sub);
+          }
         }
+        ws.send(JSON.stringify({
+          type: "terminal.killed",
+          payload: { sessionId: message.payload.sessionId }
+        }));
       }
-    }, turnMetrics),
-    stepDoneCalled
-  };
+      break;
+    }
+  }
 }
-function buildSnapshot(sessionManager2, sessionId, lastStats) {
-  const eventStore = getEventStore();
-  const session = sessionManager2.requireSession(sessionId);
-  const events = eventStore.getEvents(sessionId);
-  const latestSeq = eventStore.getLatestSeq(sessionId) ?? 0;
-  return buildSnapshotFromSessionState({
-    session,
-    events,
-    latestSeq
-  });
+function unsubscribeAllFromTerminal(ws) {
+  for (const sub of subscriptions) {
+    if (sub.ws === ws) {
+      subscriptions.delete(sub);
+    }
+  }
 }
 
 // src/server/workflows/registry.ts
@@ -1465,7 +1519,7 @@ async function deleteWorkflow(configDir, workflowId) {
 
 // src/server/runner/types.ts
 var RUNNER_CONFIG = {
-  maxVerifyRetries: 4
+  maxVerifyRetries: 10
   // Max times to retry a failing criterion
 };
 
@@ -1474,14 +1528,14 @@ var TERMINAL_DONE = "$done";
 var TERMINAL_BLOCKED = "$blocked";
 
 // src/server/workflows/shell.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function executeShellCommand(command, cwd, timeout, signal) {
   return new Promise((resolve2, reject) => {
     if (signal?.aborted) {
       reject(new Error("Aborted"));
       return;
     }
-    const proc = spawn("sh", ["-c", command], {
+    const proc = spawn2("sh", ["-c", command], {
       cwd,
       env: { ...process.env, FORCE_COLOR: "0" },
       stdio: ["ignore", "pipe", "pipe"]
@@ -1588,7 +1642,7 @@ function evaluateTransitions(transitions, criteria, stepOutcome) {
   }
   return TERMINAL_BLOCKED;
 }
-function getCurrentWindowMessageOptions2(sessionId) {
+function getCurrentWindowMessageOptions(sessionId) {
   const contextWindowId = getCurrentContextWindowId(sessionId);
   return contextWindowId ? { contextWindowId } : void 0;
 }
@@ -1597,21 +1651,21 @@ function buildReason(criteria) {
   return `${remaining.length} criteria remaining`;
 }
 async function executeWorkflow(workflow, options) {
-  const { sessionManager: sessionManager2, sessionId, llmClient, signal, onMessage } = options;
+  const { sessionManager, sessionId, llmClient, signal, onMessage } = options;
   const eventStore = getEventStore();
   const startTime = performance.now();
   let iterations = 0;
   let currentStepId = workflow.entryStep;
   let lastStepOutput = {};
   let isFirstBuilderEntry = true;
-  const messagesBeforeWorkflow = sessionManager2.requireSession(sessionId).messages.length;
+  const messagesBeforeWorkflow = sessionManager.requireSession(sessionId).messages.length;
   const stepsById = /* @__PURE__ */ new Map();
   for (const step of workflow.steps) {
     stepsById.set(step.id, step);
   }
   logger.debug("Workflow executor starting", { sessionId, workflow: workflow.metadata.id });
   if (workflow.startCondition && workflow.startCondition.type !== "always") {
-    const session = sessionManager2.requireSession(sessionId);
+    const session = sessionManager.requireSession(sessionId);
     const criteria = session.criteria;
     const conditionMet = evaluateCondition(
       workflow.startCondition,
@@ -1628,7 +1682,7 @@ async function executeWorkflow(workflow, options) {
     }
   }
   const startMsgId = crypto.randomUUID();
-  const startWindowOpts = getCurrentWindowMessageOptions2(sessionId);
+  const startWindowOpts = getCurrentWindowMessageOptions(sessionId);
   eventStore.append(sessionId, createMessageStartEvent(
     startMsgId,
     "user",
@@ -1637,7 +1691,7 @@ async function executeWorkflow(workflow, options) {
   ));
   eventStore.append(sessionId, { type: "message.done", data: { messageId: startMsgId } });
   if (options.userMessage) {
-    sessionManager2.addMessage(sessionId, {
+    sessionManager.addMessage(sessionId, {
       role: "user",
       content: options.userMessage.content,
       ...options.userMessage.attachments ? { attachments: options.userMessage.attachments } : {}
@@ -1662,8 +1716,8 @@ async function executeWorkflow(workflow, options) {
         totalTime: (performance.now() - startTime) / 1e3
       };
     }
-    const session = sessionManager2.requireSession(sessionId);
-    const currentWindowMessageOptions = getCurrentWindowMessageOptions2(sessionId);
+    const session = sessionManager.requireSession(sessionId);
+    const currentWindowMessageOptions = getCurrentWindowMessageOptions(sessionId);
     const criteria = session.criteria;
     const templateCtx = {
       workdir: session.workdir,
@@ -1677,7 +1731,7 @@ async function executeWorkflow(workflow, options) {
       modifiedFiles: formatModifiedFiles(session),
       stepOutput: lastStepOutput
     };
-    sessionManager2.setPhase(sessionId, step.phase);
+    sessionManager.setPhase(sessionId, step.phase);
     logger.debug("Workflow step executing", { sessionId, iteration: iterations, stepId: step.id, stepType: step.type });
     let stepOutcome = null;
     switch (step.type) {
@@ -1694,9 +1748,21 @@ async function executeWorkflow(workflow, options) {
           eventStore.append(sessionId, createMessageStartEvent(promptMsgId, "user", promptContent, {
             ...currentWindowMessageOptions ?? {},
             isSystemGenerated: true,
-            messageKind: "auto-prompt"
+            messageKind: "auto-prompt",
+            metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
           }));
           eventStore.append(sessionId, { type: "message.done", data: { messageId: promptMsgId } });
+          if (onMessage) {
+            onMessage(createChatMessageMessage({
+              id: promptMsgId,
+              role: "user",
+              content: promptContent,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              isSystemGenerated: true,
+              messageKind: "auto-prompt",
+              metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
+            }));
+          }
         } else if (!isFirstBuilderEntry) {
           const parts = [];
           if (agentStep.nudgePrompt) {
@@ -1709,13 +1775,25 @@ async function executeWorkflow(workflow, options) {
           eventStore.append(sessionId, createMessageStartEvent(nudgeMsgId, "user", nudgeContent, {
             ...currentWindowMessageOptions ?? {},
             isSystemGenerated: true,
-            messageKind: "correction"
+            messageKind: "correction",
+            metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
           }));
           eventStore.append(sessionId, { type: "message.done", data: { messageId: nudgeMsgId } });
+          if (onMessage) {
+            onMessage(createChatMessageMessage({
+              id: nudgeMsgId,
+              role: "user",
+              content: nudgeContent,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              isSystemGenerated: true,
+              messageKind: "correction",
+              metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
+            }));
+          }
         }
         const turnMetrics = new TurnMetrics();
         const agentResult = await runBuilderTurn({
-          sessionManager: sessionManager2,
+          sessionManager,
           sessionId,
           llmClient,
           injectStepDone: true,
@@ -1757,7 +1835,7 @@ async function executeWorkflow(workflow, options) {
         const result = await executeSubAgent({
           subAgentType: subStep.subAgentType,
           prompt: resolvedPrompt,
-          sessionManager: sessionManager2,
+          sessionManager,
           sessionId,
           llmClient,
           toolRegistry: filteredToolRegistry,
@@ -1780,8 +1858,20 @@ async function executeWorkflow(workflow, options) {
         eventStore.append(sessionId, createMessageStartEvent(shellMsgId, "user", `Running: \`${command}\``, {
           ...currentWindowMessageOptions ?? {},
           isSystemGenerated: true,
-          messageKind: "auto-prompt"
+          messageKind: "auto-prompt",
+          metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
         }));
+        if (onMessage) {
+          onMessage(createChatMessageMessage({
+            id: shellMsgId,
+            role: "user",
+            content: `Running: \`${command}\``,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            isSystemGenerated: true,
+            messageKind: "auto-prompt",
+            metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
+          }));
+        }
         const result = await executeShellCommand(command, session.workdir, timeout, signal);
         const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
         lastStepOutput = { stdout: result.stdout ?? "", stderr: result.stderr ?? "", exitCode: String(result.exitCode) };
@@ -1797,20 +1887,30 @@ ${output.slice(0, 1e4)}
           messageKind: "correction"
         }));
         eventStore.append(sessionId, { type: "message.done", data: { messageId: outputMsgId } });
+        if (onMessage) {
+          onMessage(createChatMessageMessage({
+            id: outputMsgId,
+            role: "user",
+            content: outputContent,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            isSystemGenerated: true,
+            messageKind: "correction"
+          }));
+        }
         stepOutcome = { result: successCodes.includes(result.exitCode) ? "success" : "failure", output: lastStepOutput };
         break;
       }
     }
-    const refreshedSession = sessionManager2.requireSession(sessionId);
+    const refreshedSession = sessionManager.requireSession(sessionId);
     const nextStepId = evaluateTransitions(
       step.transitions,
       refreshedSession.criteria,
       stepOutcome
     );
     if (nextStepId === TERMINAL_DONE) {
-      sessionManager2.setPhase(sessionId, "done");
+      sessionManager.setPhase(sessionId, "done");
       const totalTimeSeconds = Math.round((performance.now() - startTime) / 100) / 10;
-      const completedSession = sessionManager2.requireSession(sessionId);
+      const completedSession = sessionManager.requireSession(sessionId);
       const workflowMessages = completedSession.messages.slice(messagesBeforeWorkflow);
       const workflowStats = computeSessionStats(workflowMessages);
       const totalToolCalls = workflowMessages.reduce(
@@ -1848,16 +1948,28 @@ ${output.slice(0, 1e4)}
       };
     }
     if (nextStepId === TERMINAL_BLOCKED) {
-      sessionManager2.setPhase(sessionId, "blocked");
+      sessionManager.setPhase(sessionId, "blocked");
       const blockedCriteria = refreshedSession.criteria.filter((c) => c.status.type === "failed" && c.attempts.filter((a) => a.status === "failed").length >= RUNNER_CONFIG.maxVerifyRetries).map((c) => c.id);
       const reason = blockedCriteria.length > 0 ? `Retry limit reached for: ${blockedCriteria.join(", ")}` : "No matching transition";
       const blockedMsgId = crypto.randomUUID();
       eventStore.append(sessionId, createMessageStartEvent(blockedMsgId, "user", `Runner blocked: ${reason}`, {
         ...currentWindowMessageOptions ?? {},
         isSystemGenerated: true,
-        messageKind: "correction"
+        messageKind: "correction",
+        metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
       }));
       eventStore.append(sessionId, { type: "message.done", data: { messageId: blockedMsgId } });
+      if (onMessage) {
+        onMessage(createChatMessageMessage({
+          id: blockedMsgId,
+          role: "user",
+          content: `Runner blocked: ${reason}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          isSystemGenerated: true,
+          messageKind: "correction",
+          metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
+        }));
+      }
       logger.warn("Workflow executor blocked", { sessionId, iterations, reason });
       const blockedAction = { type: "BLOCKED", reason, blockedCriteria };
       return {
@@ -1890,302 +2002,50 @@ async function runOrchestrator(options) {
   return executeWorkflow(workflow, options);
 }
 
-// src/server/db/sessions.ts
-function createSession(projectId, workdir, title, providerId, providerModel) {
-  const db = getDatabase();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const id = crypto.randomUUID();
-  db.prepare(`
-    INSERT INTO sessions (id, project_id, workdir, phase, mode, workflow_phase, is_running, created_at, updated_at, title, provider_id, provider_model)
-    VALUES (?, ?, ?, 'idle', 'planner', 'plan', 0, ?, ?, ?, ?, ?)
-  `).run(id, projectId, workdir, now, now, title ?? null, providerId ?? null, providerModel ?? null);
-  return {
-    id,
-    projectId,
-    workdir,
-    mode: "planner",
-    phase: "plan",
-    isRunning: false,
-    summary: null,
-    providerId: providerId ?? null,
-    providerModel: providerModel ?? null,
-    createdAt: now,
-    updatedAt: now,
-    messages: [],
-    criteria: [],
-    contextWindows: [],
-    executionState: null,
-    metadata: {
-      ...title ? { title } : {},
-      totalTokensUsed: 0,
-      totalToolCalls: 0,
-      iterationCount: 0
-    }
-  };
-}
-function getSession(id) {
-  const db = getDatabase();
-  const row = db.prepare(`
-    SELECT * FROM sessions WHERE id = ?
-  `).get(id);
-  if (!row) {
-    return null;
-  }
-  return {
-    id: row.id,
-    projectId: row.project_id,
-    workdir: row.workdir,
-    mode: row.mode ?? "planner",
-    phase: row.workflow_phase ?? "plan",
-    isRunning: Boolean(row.is_running),
-    summary: row.summary ?? null,
-    providerId: row.provider_id ?? null,
-    providerModel: row.provider_model ?? null,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-    messages: [],
-    criteria: [],
-    contextWindows: [],
-    executionState: null,
-    metadata: {
-      ...row.title ? { title: row.title } : {},
-      totalTokensUsed: row.total_tokens_used,
-      totalToolCalls: row.total_tool_calls,
-      iterationCount: row.iteration_count
-    }
-  };
-}
-function updateSessionProvider(id, providerId, providerModel) {
-  const db = getDatabase();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.prepare(`
-    UPDATE sessions SET provider_id = ?, provider_model = ?, updated_at = ? WHERE id = ?
-  `).run(providerId, providerModel, now, id);
-}
-function updateSessionSummary(id, summary) {
-  const db = getDatabase();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.prepare(`
-    UPDATE sessions SET summary = ?, updated_at = ? WHERE id = ?
-  `).run(summary, now, id);
-}
-function updateSessionMetadata(id, metadata) {
-  const db = getDatabase();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const updates = ["updated_at = ?"];
-  const values = [now];
-  if (metadata.title !== void 0) {
-    updates.push("title = ?");
-    values.push(metadata.title ?? "");
-  }
-  if (metadata.totalTokensUsed !== void 0) {
-    updates.push("total_tokens_used = ?");
-    values.push(metadata.totalTokensUsed);
-  }
-  if (metadata.totalToolCalls !== void 0) {
-    updates.push("total_tool_calls = ?");
-    values.push(metadata.totalToolCalls);
-  }
-  if (metadata.iterationCount !== void 0) {
-    updates.push("iteration_count = ?");
-    values.push(metadata.iterationCount);
-  }
-  values.push(id);
-  db.prepare(`
-    UPDATE sessions SET ${updates.join(", ")} WHERE id = ?
-  `).run(...values);
-}
-function listSessions() {
-  const db = getDatabase();
-  const rows = db.prepare(`
-    SELECT
-      s.id,
-      s.project_id,
-      s.workdir,
-      s.mode,
-      s.workflow_phase,
-      s.is_running,
-      s.created_at,
-      s.updated_at,
-      s.title,
-      s.provider_id,
-      s.provider_model,
-      COALESCE(
-        (SELECT COUNT(*) FROM events e 
-         WHERE e.session_id = s.id 
-         AND e.event_type = 'message.start'
-         AND json_extract(e.payload, '$.role') IN ('user', 'assistant'))
-        +
-        COALESCE(
-          (SELECT SUM(json_array_length(json_extract(e.payload, '$.messages'))) FROM events e
-           WHERE e.session_id = s.id
-           AND e.event_type = 'turn.snapshot'
-           AND json_extract(e.payload, '$.messages') IS NOT NULL),
-          0
-        ),
-        0
-      ) as message_count
-    FROM sessions s
-    ORDER BY s.updated_at DESC
-  `).all();
-  return rows.map((row) => ({
-    id: row.id,
-    projectId: row.project_id,
-    ...row.title ? { title: row.title } : {},
-    workdir: row.workdir,
-    mode: row.mode ?? "planner",
-    phase: row.workflow_phase ?? "plan",
-    isRunning: Boolean(row.is_running),
-    providerId: row.provider_id ?? null,
-    providerModel: row.provider_model ?? null,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-    criteriaCount: 0,
-    // Derived from events
-    criteriaCompleted: 0,
-    // Derived from events
-    messageCount: row.message_count
-  }));
-}
-function listSessionsByProject(projectId) {
-  const db = getDatabase();
-  const rows = db.prepare(`
-    SELECT
-      s.id,
-      s.project_id,
-      s.workdir,
-      s.mode,
-      s.workflow_phase,
-      s.is_running,
-      s.created_at,
-      s.updated_at,
-      s.title,
-      s.provider_id,
-      s.provider_model,
-      COALESCE(
-        (SELECT COUNT(*) FROM events e 
-         WHERE e.session_id = s.id 
-         AND e.event_type = 'message.start'
-         AND json_extract(e.payload, '$.role') IN ('user', 'assistant'))
-        +
-        COALESCE(
-          (SELECT SUM(json_array_length(json_extract(e.payload, '$.messages'))) FROM events e
-           WHERE e.session_id = s.id
-           AND e.event_type = 'turn.snapshot'
-           AND json_extract(e.payload, '$.messages') IS NOT NULL),
-          0
-        ),
-        0
-      ) as message_count
-    FROM sessions s
-    WHERE s.project_id = ?
-    ORDER BY s.updated_at DESC
-  `).all(projectId);
-  return rows.map((row) => ({
-    id: row.id,
-    projectId: row.project_id,
-    ...row.title ? { title: row.title } : {},
-    workdir: row.workdir,
-    mode: row.mode ?? "planner",
-    phase: row.workflow_phase ?? "plan",
-    isRunning: Boolean(row.is_running),
-    providerId: row.provider_id ?? null,
-    providerModel: row.provider_model ?? null,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-    criteriaCount: 0,
-    // Derived from events
-    criteriaCompleted: 0,
-    // Derived from events
-    messageCount: row.message_count
-  }));
-}
-function deleteSession(id) {
-  const db = getDatabase();
-  db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
-}
-
-// src/server/session/name-generator.ts
-var SESSION_NAME_PROMPT = `Generate a concise, descriptive session name (max 50 characters) based on the user's message.
-Return ONLY the name, nothing else.
-
-Example inputs and outputs:
-- "How do I set up React?" \u2192 "React setup"
-- "Fix the authentication bug" \u2192 "Fix authentication bug"
-- "Add unit tests for the API" \u2192 "Add API unit tests"
-
-User message: {message}`;
-async function generateSessionName(options) {
-  const { userMessage, llmClient, signal } = options;
-  try {
-    const prompt = SESSION_NAME_PROMPT.replace("{message}", userMessage);
-    const messages = [
-      {
-        role: "user",
-        content: prompt
-      }
-    ];
-    const timeoutSignal = AbortSignal.timeout(6e4);
-    const composedSignal = signal ? AbortSignal.any([timeoutSignal, signal]) : timeoutSignal;
-    const response = await llmClient.complete({
-      messages,
-      tools: [],
-      signal: composedSignal,
-      disableThinking: true
-    });
-    let name = response.content.trim();
-    if (name.length > 50) {
-      name = name.substring(0, 47) + "...";
-    }
-    if (!name || name.length < 3) {
-      return {
-        success: false,
-        error: "Generated name is too short or empty"
-      };
-    }
-    return {
-      success: true,
-      name
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error generating session name"
-    };
-  }
-}
-function needsNameGeneration(sessionTitle, messageCount) {
-  if (messageCount > 1) {
-    return false;
-  }
-  if (!sessionTitle || sessionTitle.trim() === "") {
-    return true;
-  }
-  if (/^Session \d+$/.test(sessionTitle)) {
-    return true;
-  }
-  return false;
-}
-
 // src/server/session/summary-generator.ts
-var SESSION_SUMMARY_PROMPT = `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.
-
-## Conversation History
-{messages}
-
-## Summary
-`;
+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 } = options;
+  const { messages, llmClient, workdir, customInstructions, skills } = options;
   try {
     const messagesText = messages.map((m) => `${m.role}: ${m.content}`).join("\n");
-    const prompt = SESSION_SUMMARY_PROMPT.replace("{messages}", messagesText);
-    const llmMessages = [
+    const userPrompt = `${SUMMARY_INSTRUCTION}
+
+## Conversation History
+${messagesText}
+
+## Summary`;
+    const contextMessages = [
       {
         role: "user",
-        content: prompt
+        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: [],
@@ -2218,7 +2078,7 @@ function needsSummaryGeneration(sessionSummary) {
 }
 
 // src/server/ws/server.ts
-function getCurrentWindowMessageOptions3(sessionId) {
+function getCurrentWindowMessageOptions2(sessionId) {
   const contextWindowId = getCurrentContextWindowId(sessionId);
   return contextWindowId ? { contextWindowId } : void 0;
 }
@@ -2236,7 +2096,7 @@ function getSessionMessageCount(sessionId) {
   }
   return count;
 }
-function resolveStatsIdentity2(llmClient, getActiveProvider) {
+function resolveStatsIdentity(llmClient, getActiveProvider) {
   const provider = getActiveProvider?.();
   const model = llmClient.getModel();
   const backend = provider?.backend ?? (llmClient.getBackend() === "unknown" ? "unknown" : llmClient.getBackend());
@@ -2248,12 +2108,12 @@ function resolveStatsIdentity2(llmClient, getActiveProvider) {
   };
 }
 var activeAgents = /* @__PURE__ */ new Map();
-function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvider, toolRegistry, sessionManager2, providerManager) {
+function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvider, sessionManager, providerManager) {
   const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
   const clients = /* @__PURE__ */ new Map();
   const sessionLLMClients = /* @__PURE__ */ new Map();
   function getSessionLLMClient(sessionId) {
-    const session = sessionManager2.getSession(sessionId);
+    const session = sessionManager.getSession(sessionId);
     if (!session?.providerId || !session?.providerModel || !providerManager) {
       return getLLMClient();
     }
@@ -2268,7 +2128,7 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
         sessionId,
         providerId: session.providerId
       });
-      sessionManager2.setSessionProvider(sessionId, null, null);
+      sessionManager.setSessionProvider(sessionId, null, null);
       sessionLLMClients.delete(sessionId);
       return getLLMClient();
     }
@@ -2286,9 +2146,9 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
     return client;
   }
   function getSessionStatsIdentity(sessionId) {
-    const session = sessionManager2.getSession(sessionId);
+    const session = sessionManager.getSession(sessionId);
     if (!session?.providerId || !providerManager) {
-      return resolveStatsIdentity2(getLLMClient(), getActiveProvider);
+      return resolveStatsIdentity(getLLMClient(), getActiveProvider);
     }
     const provider = providerManager.getProviders().find((p) => p.id === session.providerId);
     const client = getSessionLLMClient(sessionId);
@@ -2307,23 +2167,128 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
   };
   const broadcastForSession = (sessionId, msg) => {
     for (const [clientWs, client] of clients) {
-      if (isSubscribedToSession(client, sessionId) && clientWs.readyState === WebSocket.OPEN) {
+      if (isSubscribedToSession(client, sessionId) && clientWs.readyState === WebSocket2.OPEN) {
         clientWs.send(serializeServerMessage({ ...msg, sessionId }));
       }
     }
   };
-  sessionManager2.subscribe((event) => {
+  const llmForSession = (sessionId) => getSessionLLMClient?.(sessionId) ?? getLLMClient();
+  const statsForSession = (sessionId) => getSessionStatsIdentity?.(sessionId) ?? resolveStatsIdentity(getLLMClient(), getActiveProvider);
+  function startTurnWithCompletionChain(sessionId, controller) {
+    runChatTurn({
+      sessionManager,
+      sessionId,
+      llmClient: llmForSession(sessionId),
+      statsIdentity: statsForSession(sessionId),
+      signal: controller.signal,
+      onMessage: (msg) => broadcastForSession(sessionId, msg)
+    }).catch((error) => {
+      if (error instanceof Error && error.message === "Aborted") {
+        return;
+      }
+      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));
+    });
+  }
+  function triggerQueueProcessing(sessionId) {
+    const currentSession = sessionManager.getSession(sessionId);
+    if (!currentSession || currentSession.isRunning) {
+      return false;
+    }
+    const queue = sessionManager.getQueueState(sessionId);
+    if (queue.length === 0) {
+      return false;
+    }
+    const controller = new AbortController();
+    activeAgents.set(sessionId, controller);
+    sessionManager.setRunning(sessionId, true);
+    const eventStore = getEventStore();
+    eventStore.append(sessionId, { type: "running.changed", data: { isRunning: true } });
+    broadcastForSession(sessionId, createSessionRunningMessage(true));
+    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));
+    }
+    startTurnWithCompletionChain(sessionId, controller);
+    return true;
+  }
+  sessionManager.subscribe((event) => {
     const sessionId = "sessionId" in event ? event.sessionId : "session" in event ? event.session.id : null;
     if (!sessionId) return;
     for (const [ws, client] of clients) {
-      if (isSubscribedToSession(client, sessionId) && ws.readyState === WebSocket.OPEN) {
+      if (ws.readyState !== WebSocket2.OPEN) continue;
+      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);
+          ws.send(serializeServerMessage({ ...createSessionStateMessage(session, messages, pendingConfirmations), sessionId }));
+        }
+        continue;
+      }
+      if (isSubscribedToSession(client, sessionId)) {
         if (event.type === "session_updated") {
-          const session = sessionManager2.getSession(sessionId);
+          const session = sessionManager.getSession(sessionId);
           if (session) {
             const eventStore = getEventStore();
             const events = eventStore.getEvents(sessionId);
             const messages = events.length > 0 ? buildMessagesFromStoredEvents(events) : [];
-            ws.send(serializeServerMessage({ ...createSessionStateMessage(session, messages), sessionId }));
+            const pendingConfirmations = foldPendingConfirmations(events);
+            ws.send(serializeServerMessage({ ...createSessionStateMessage(session, messages, pendingConfirmations), sessionId }));
           }
         }
         if (event.type === "running_changed") {
@@ -2335,7 +2300,7 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
   const broadcastAll = (msg) => {
     const serialized = serializeServerMessage(msg);
     for (const [clientWs] of clients) {
-      if (clientWs.readyState === WebSocket.OPEN) {
+      if (clientWs.readyState === WebSocket2.OPEN) {
         clientWs.send(serialized);
       }
     }
@@ -2363,9 +2328,13 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
         ws.send(serializeServerMessage(createErrorMessage("INVALID_MESSAGE", "Invalid message format")));
         return;
       }
+      if (message.type.startsWith("terminal.")) {
+        handleTerminalMessage(ws, message);
+        return;
+      }
       const client = clients.get(ws);
       try {
-        await handleClientMessage(ws, client, message, config, getLLMClient, getActiveProvider, toolRegistry, sessionManager2, broadcastForSession, providerManager, getSessionLLMClient, getSessionStatsIdentity, invalidateSessionLLMClient);
+        await handleClientMessage(ws, client, message, getLLMClient, getActiveProvider, sessionManager, broadcastForSession, providerManager, getSessionLLMClient, getSessionStatsIdentity, llmForSession, statsForSession, startTurnWithCompletionChain);
       } catch (error) {
         logger.error("Error handling client message", { error, type: message.type });
         ws.send(serializeServerMessage(
@@ -2388,17 +2357,31 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
           unsubscribe();
         }
       }
+      unsubscribeAllFromTerminal(ws);
       clients.delete(ws);
     });
     ws.on("error", (error) => {
       logger.error("WebSocket error", { error });
     });
   });
-  return wss;
+  return {
+    wss,
+    abortSession: (sessionId) => {
+      const controller = activeAgents.get(sessionId);
+      if (controller) {
+        activeAgents.delete(sessionId);
+        controller.abort();
+        return true;
+      }
+      return false;
+    },
+    close: (cb) => wss.close(cb),
+    broadcastForSession
+  };
 }
-async function handleClientMessage(ws, client, message, config, getLLMClient, getActiveProvider, toolRegistry, sessionManager2, broadcastForSession, providerManager, getSessionLLMClient, getSessionStatsIdentity, invalidateSessionLLMClient) {
+async function handleClientMessage(ws, client, message, getLLMClient, getActiveProvider, sessionManager, broadcastForSession, providerManager, getSessionLLMClient, getSessionStatsIdentity, llmForSession, statsForSession, startTurnWithCompletionChain) {
   const send = (msg) => {
-    if (ws.readyState === WebSocket.OPEN) {
+    if (ws.readyState === WebSocket2.OPEN) {
       ws.send(serializeServerMessage(msg));
     }
   };
@@ -2414,57 +2397,13 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
     controller.abort();
     cancelQuestionsForSession(sessionId, reason);
     cancelPathConfirmationsForSession(sessionId, reason);
-    sessionManager2.clearMessageQueue(sessionId);
-    sessionManager2.setRunning(sessionId, false);
+    sessionManager.clearMessageQueue(sessionId);
+    sessionManager.setRunning(sessionId, false);
     sendForSession(sessionId, createSessionRunningMessage(false));
-    const contextState = sessionManager2.getContextState(sessionId);
+    const contextState = sessionManager.getContextState(sessionId);
     sendForSession(sessionId, createContextStateMessage(contextState));
     return true;
   };
-  const llmForSession = (sessionId) => getSessionLLMClient?.(sessionId) ?? getLLMClient();
-  const statsForSession = (sessionId) => getSessionStatsIdentity?.(sessionId) ?? resolveStatsIdentity2(getLLMClient(), getActiveProvider);
-  const startTurnWithCompletionChain = (sessionId, controller) => {
-    runChatTurn({
-      sessionManager: sessionManager2,
-      sessionId,
-      llmClient: llmForSession(sessionId),
-      statsIdentity: statsForSession(sessionId),
-      signal: controller.signal,
-      onMessage: (msg) => sendForSession(sessionId, msg)
-    }).catch((error) => {
-      if (error instanceof Error && error.message === "Aborted") {
-        return;
-      }
-      logger.error("Chat turn error", { error });
-    }).finally(() => {
-      if (activeAgents.get(sessionId) !== controller) {
-        return;
-      }
-      activeAgents.delete(sessionId);
-      const completionMsgs = sessionManager2.drainCompletionMessages(sessionId);
-      const next = completionMsgs[0];
-      if (next) {
-        for (const remaining of completionMsgs.slice(1)) {
-          sessionManager2.queueMessage(sessionId, "completion", remaining.content, remaining.attachments);
-        }
-        sendForSession(sessionId, createQueueStateMessage(sessionManager2.getQueueState(sessionId)));
-        const userMessage = sessionManager2.addMessage(sessionId, {
-          role: "user",
-          content: next.content,
-          ...next.attachments ? { attachments: next.attachments } : {}
-        });
-        sendForSession(sessionId, createChatMessageMessage(userMessage));
-        const newController = new AbortController();
-        activeAgents.set(sessionId, newController);
-        startTurnWithCompletionChain(sessionId, newController);
-        return;
-      }
-      sessionManager2.clearMessageQueue(sessionId);
-      sessionManager2.setRunning(sessionId, false);
-      const contextState = sessionManager2.getContextState(sessionId);
-      sendForSession(sessionId, createContextStateMessage(contextState));
-    });
-  };
   const ensureEventStoreSubscription = (sessionId) => {
     if (client.eventStoreSubscriptions.has(sessionId)) {
       return;
@@ -2477,7 +2416,7 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
       try {
         for await (const storedEvent of iterator) {
           const serverMsg = storedEventToServerMessage(storedEvent);
-          if (serverMsg && ws.readyState === WebSocket.OPEN) {
+          if (serverMsg && ws.readyState === WebSocket2.OPEN) {
             ws.send(serializeServerMessage({ ...serverMsg, seq: storedEvent.seq, sessionId: sid }));
           }
         }
@@ -2489,138 +2428,36 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
   };
   switch (message.type) {
     // =========================================================================
-    // Project Management
-    // =========================================================================
-    case "project.create": {
-      if (!isProjectCreatePayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid project.create payload", message.id));
-        return;
-      }
-      const project = createProject(message.payload.name, message.payload.workdir);
-      send(createProjectStateMessage(project, message.id));
-      break;
-    }
-    case "project.create-with-dir": {
-      logger.debug("WS project.create-with-dir received", { payload: message.payload });
-      if (!isProjectCreateWithDirPayload(message.payload)) {
-        logger.error("WS project.create-with-dir invalid payload");
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid project.create-with-dir payload", message.id));
-        return;
-      }
-      try {
-        const workdir = config.workdir;
-        logger.debug("WS creating project directory", { name: message.payload.name, workdir });
-        const { createDirectoryWithGit } = await import("./project-creator-CWPKRIKI.js");
-        const project = await createDirectoryWithGit(message.payload.name, workdir);
-        logger.debug("WS project created", { id: project.id, name: project.name });
-        send(createProjectStateMessage(project, message.id));
-        logger.debug("WS sent project.state", { messageId: message.id });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        logger.error("WS project creation failed", { error: errorMessage });
-        send(createErrorMessage("PROJECT_CREATION_FAILED", errorMessage, message.id));
-      }
-      break;
-    }
-    case "project.list": {
-      logger.debug("WS project.list received", { messageId: message.id });
-      const projects = listProjects();
-      logger.debug("WS projects found", { count: projects.length, projects: projects.map((p) => ({ id: p.id, name: p.name })) });
-      send(createProjectListMessage(projects, message.id));
-      logger.debug("WS sent project.list", { messageId: message.id });
-      break;
-    }
-    case "project.load": {
-      if (!isProjectLoadPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid project.load payload", message.id));
-        return;
-      }
-      const project = getProject(message.payload.projectId);
-      if (!project) {
-        send(createErrorMessage("NOT_FOUND", "Project not found", message.id));
-        return;
-      }
-      send(createProjectStateMessage(project, message.id));
-      break;
-    }
-    case "project.update": {
-      if (!isProjectUpdatePayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid project.update payload", message.id));
-        return;
-      }
-      const updates = {};
-      if (message.payload.name !== void 0) {
-        updates.name = message.payload.name;
-      }
-      if (message.payload.customInstructions !== void 0) {
-        updates.customInstructions = message.payload.customInstructions;
-      }
-      const updated = updateProject(message.payload.projectId, updates);
-      if (!updated) {
-        send(createErrorMessage("NOT_FOUND", "Project not found", message.id));
-        return;
-      }
-      send(createProjectStateMessage(updated, message.id));
-      break;
-    }
-    case "project.delete": {
-      if (!isProjectDeletePayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid project.delete payload", message.id));
-        return;
-      }
-      deleteProject(message.payload.projectId);
-      send({ type: "project.deleted", payload: { projectId: message.payload.projectId }, id: message.id });
-      break;
-    }
-    // =========================================================================
-    // Settings Management
+    // DEPRECATED: All CRUD operations moved to REST API
+    // If you see this error, update your code to use REST endpoints instead.
+    // See docs/REST-API.md for details.
     // =========================================================================
-    case "settings.get": {
-      if (!isSettingsGetPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid settings.get payload", message.id));
-        return;
-      }
-      const value = getSetting(message.payload.key);
-      send(createSettingsValueMessage(message.payload.key, value, message.id));
-      break;
-    }
-    case "settings.set": {
-      if (!isSettingsSetPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid settings.set payload", message.id));
-        return;
-      }
-      setSetting(message.payload.key, message.payload.value);
-      send(createSettingsValueMessage(message.payload.key, message.payload.value, message.id));
-      break;
-    }
+    case "project.create":
+    case "project.create-with-dir":
+    case "project.list":
+    case "project.load":
+    case "project.update":
+    case "project.delete":
+    case "settings.get":
+    case "settings.set":
+    case "session.create":
+    case "session.list":
+    case "session.delete":
+    case "session.deleteAll":
+    case "session.setProvider":
+      send(createErrorMessage("DEPRECATED_MESSAGE_TYPE", `${message.type} removed. Use REST API instead. See docs/REST-API.md`, message.id));
+      return;
     // =========================================================================
-    // Session Management
+    // Session Load - Required for WS subscription mechanism
+    // Note: This is kept ONLY to set activeSessionId for event routing.
+    // For actual data loading, use REST API: GET /api/sessions/:id
     // =========================================================================
-    case "session.create": {
-      if (!isSessionCreatePayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid session.create payload", message.id));
-        return;
-      }
-      const currentProvider = providerManager?.getActiveProvider();
-      const currentModel = currentProvider ? getLLMClient().getModel() : null;
-      const session = sessionManager2.createSession(
-        message.payload.projectId,
-        message.payload.title,
-        currentProvider?.id ?? null,
-        currentModel
-      );
-      client.activeSessionId = session.id;
-      sendForSession(session.id, createSessionStateMessage(session, [], message.id));
-      const contextState = sessionManager2.getContextState(session.id);
-      sendForSession(session.id, createContextStateMessage(contextState));
-      break;
-    }
     case "session.load": {
       if (!isSessionLoadPayload(message.payload)) {
         send(createErrorMessage("INVALID_PAYLOAD", "Invalid session.load payload", message.id));
         return;
       }
-      const session = sessionManager2.getSession(message.payload.sessionId);
+      const session = sessionManager.getSession(message.payload.sessionId);
       if (!session) {
         send(createErrorMessage("NOT_FOUND", "Session not found", message.id));
         return;
@@ -2630,77 +2467,15 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
       const eventStore = getEventStore();
       const events = eventStore.getEvents(session.id);
       const messages = buildMessagesFromStoredEvents(events);
-      logger.debug("Loaded messages from EventStore", { sessionId: session.id, eventCount: events.length, messageCount: messages.length });
-      sendForSession(session.id, createSessionStateMessage(session, messages, message.id));
-      const contextState = sessionManager2.getContextState(session.id);
+      const pendingConfirmations = foldPendingConfirmations(events);
+      logger.debug("Loaded messages from EventStore", { sessionId: session.id, eventCount: events.length, messageCount: messages.length, pendingConfirmationsCount: pendingConfirmations.length });
+      sendForSession(session.id, createSessionStateMessage(session, messages, pendingConfirmations, message.id));
+      const contextState = sessionManager.getContextState(session.id);
       sendForSession(session.id, createContextStateMessage(contextState));
       break;
     }
-    case "session.list": {
-      const sessions = sessionManager2.listSessions();
-      const sessionsWithPrompts = sessions.map((session) => ({
-        ...session,
-        recentUserPrompts: getRecentUserPromptsForSession(session.id, 10)
-      }));
-      send(createSessionListMessage(sessionsWithPrompts, message.id));
-      break;
-    }
-    case "session.delete": {
-      if (!isSessionLoadPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid session.delete payload", message.id));
-        return;
-      }
-      sessionManager2.deleteSession(message.payload.sessionId);
-      send({ type: "session.deleted", payload: { sessionId: message.payload.sessionId }, id: message.id });
-      break;
-    }
-    case "session.deleteAll": {
-      if (!message.payload || typeof message.payload !== "object" || !("projectId" in message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid session.deleteAll payload", message.id));
-        return;
-      }
-      const payload = message.payload;
-      const project = sessionManager2.getProject(payload.projectId);
-      if (!project) {
-        send(createErrorMessage("PROJECT_NOT_FOUND", "Project not found", message.id));
-        return;
-      }
-      sessionManager2.deleteAllSessions(payload.projectId, project.workdir);
-      send({ type: "session.deletedAll", payload: { projectId: payload.projectId }, id: message.id });
-      break;
-    }
-    case "session.setProvider": {
-      if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
-        return;
-      }
-      if (!isSessionSetProviderPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid session.setProvider payload", message.id));
-        return;
-      }
-      if (!providerManager) {
-        send(createErrorMessage("NO_PROVIDERS", "Provider management not available", message.id));
-        return;
-      }
-      const { providerId, model: requestedModel } = message.payload;
-      const provider = providerManager.getProviders().find((p) => p.id === providerId);
-      if (!provider) {
-        send(createErrorMessage("PROVIDER_NOT_FOUND", "Provider not found", message.id));
-        return;
-      }
-      const resolvedModel = requestedModel ?? "auto";
-      const sessionId = client.activeSessionId;
-      sessionManager2.setSessionProvider(sessionId, providerId, resolvedModel);
-      invalidateSessionLLMClient?.(sessionId);
-      const eventStore = getEventStore();
-      const updatedSession = sessionManager2.requireSession(sessionId);
-      const events = eventStore.getEvents(sessionId);
-      const messages = buildMessagesFromStoredEvents(events);
-      sendForSession(sessionId, createSessionStateMessage(updatedSession, messages, message.id));
-      break;
-    }
     // =========================================================================
-    // Unified Chat (replaces plan.message, agent.start, etc.)
+    // Unified Chat (replaces plan.message, agent.start, etc.) - WS REQUIRED
     // =========================================================================
     case "chat.send": {
       if (!client.activeSessionId) {
@@ -2711,15 +2486,15 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
         send(createErrorMessage("INVALID_PAYLOAD", "Invalid chat.send payload", message.id));
         return;
       }
-      const currentSession = sessionManager2.requireSession(client.activeSessionId);
+      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 });
-        sessionManager2.setPhase(client.activeSessionId, "build");
-        sessionManager2.resetAllCriteriaAttempts(client.activeSessionId);
+        sessionManager.setPhase(client.activeSessionId, "build");
+        sessionManager.resetAllCriteriaAttempts(client.activeSessionId);
         sendForSession(client.activeSessionId, createPhaseChangedMessage("build"));
       }
       const sessionId = client.activeSessionId;
@@ -2732,12 +2507,12 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
         existingController.abort();
       }
       activeAgents.set(sessionId, controller);
-      sessionManager2.setRunning(sessionId, true);
+      sessionManager.setRunning(sessionId, true);
       sendForSession(sessionId, createSessionRunningMessage(true));
       send({ type: "ack", payload: {}, id: message.id });
       try {
         await maybeAutoCompactContext({
-          sessionManager: sessionManager2,
+          sessionManager,
           sessionId,
           llmClient: llmForSession(sessionId),
           statsIdentity: statsForSession(sessionId),
@@ -2746,7 +2521,7 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
         if (controller.signal.aborted) {
           break;
         }
-        const userMessage = sessionManager2.addMessage(sessionId, {
+        const userMessage = sessionManager.addMessage(sessionId, {
           role: "user",
           content: message.payload.content,
           ...message.payload.attachments && { attachments: message.payload.attachments },
@@ -2767,11 +2542,12 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
                 type: "session.name_generated",
                 data: { name: result.name }
               });
-              const updatedSession = sessionManager2.getSession(sessionId);
+              const updatedSession = sessionManager.getSession(sessionId);
               if (updatedSession) {
                 const events = eventStore.getEvents(sessionId);
                 const messages = buildMessagesFromStoredEvents(events);
-                broadcastForSession(sessionId, createSessionStateMessage(updatedSession, messages));
+                const pendingConfirmations = foldPendingConfirmations(events);
+                broadcastForSession(sessionId, createSessionStateMessage(updatedSession, messages, pendingConfirmations));
               }
               logger.info("Session name generated", { sessionId, name: result.name });
             }
@@ -2784,9 +2560,9 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
         if (activeAgents.get(sessionId) === controller) {
           activeAgents.delete(sessionId);
         }
-        sessionManager2.setRunning(sessionId, false);
+        sessionManager.setRunning(sessionId, false);
         sendForSession(sessionId, createSessionRunningMessage(false));
-        const contextState = sessionManager2.getContextState(sessionId);
+        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 });
@@ -2795,134 +2571,33 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
       break;
     }
     case "chat.stop": {
-      if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
-        return;
-      }
-      abortSessionExecution(client.activeSessionId, "Session aborted by user");
-      send({ type: "ack", payload: {}, id: message.id });
+      send(createErrorMessage("DEPRECATED", "chat.stop removed. Use REST API: POST /api/sessions/:id/stop", message.id));
       break;
     }
     // =========================================================================
     // Message Queue
-    // =========================================================================
-    case "queue.asap": {
-      if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
-        return;
-      }
-      if (!isQueueAsapPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid queue.asap payload", message.id));
-        return;
-      }
-      const { content, attachments } = message.payload;
-      sessionManager2.queueMessage(client.activeSessionId, "asap", content, attachments);
-      sendForSession(client.activeSessionId, createQueueStateMessage(sessionManager2.getQueueState(client.activeSessionId)));
-      send({ type: "ack", payload: {}, id: message.id });
+    // =========================================================================
+    case "queue.asap": {
+      send(createErrorMessage("DEPRECATED", "queue.asap removed. Use REST API: POST /api/sessions/:id/queue/asap", message.id));
       break;
     }
     case "queue.completion": {
-      if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
-        return;
-      }
-      if (!isQueueCompletionPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid queue.completion payload", message.id));
-        return;
-      }
-      const { content, attachments } = message.payload;
-      sessionManager2.queueMessage(client.activeSessionId, "completion", content, attachments);
-      sendForSession(client.activeSessionId, createQueueStateMessage(sessionManager2.getQueueState(client.activeSessionId)));
-      send({ type: "ack", payload: {}, id: message.id });
+      send(createErrorMessage("DEPRECATED", "queue.completion removed. Use REST API: POST /api/sessions/:id/queue/completion", message.id));
       break;
     }
     case "queue.cancel": {
-      if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
-        return;
-      }
-      if (!isQueueCancelPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid queue.cancel payload", message.id));
-        return;
-      }
-      sessionManager2.cancelQueuedMessage(client.activeSessionId, message.payload.queueId);
-      sendForSession(client.activeSessionId, createQueueStateMessage(sessionManager2.getQueueState(client.activeSessionId)));
-      send({ type: "ack", payload: {}, id: message.id });
+      send(createErrorMessage("DEPRECATED", "queue.cancel removed. Use REST API: DELETE /api/sessions/:id/queue/:queueId", message.id));
       break;
     }
     case "chat.continue": {
-      if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
-        return;
-      }
-      const session = sessionManager2.requireSession(client.activeSessionId);
-      if (session.isRunning) {
-        send(createErrorMessage("ALREADY_RUNNING", "Session is already running", message.id));
-        return;
-      }
-      const continueEventStore = getEventStore();
-      const events = continueEventStore.getEvents(session.id);
-      const messages = buildMessagesFromStoredEvents(events);
-      const lastAssistantMessage = [...messages].reverse().find((msg) => msg.role === "assistant");
-      const fallbackMessageId = lastAssistantMessage?.id ?? [...messages].reverse().find((msg) => msg.role === "user")?.id ?? crypto.randomUUID();
-      send({ type: "ack", payload: {}, id: message.id });
-      sendForSession(session.id, createChatDoneMessage(fallbackMessageId, "complete", lastAssistantMessage?.stats));
+      send(createErrorMessage("DEPRECATED", "chat.continue removed. Use REST API: POST /api/sessions/:id/continue", message.id));
       break;
     }
     // =========================================================================
     // Mode Switching
     // =========================================================================
     case "mode.switch": {
-      if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
-        return;
-      }
-      if (!isModeSwitchPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid mode.switch payload", message.id));
-        return;
-      }
-      const allAgents = await loadAllAgentsDefault();
-      const targetAgent = findAgentById(message.payload.mode, allAgents);
-      if (!targetAgent || targetAgent.metadata.subagent) {
-        send(createErrorMessage("INVALID_AGENT", `Agent '${message.payload.mode}' not found or is a sub-agent`, message.id));
-        return;
-      }
-      const sessionId = client.activeSessionId;
-      const session = sessionManager2.requireSession(sessionId);
-      const eventStore = getEventStore();
-      if (message.payload.mode === "builder" && needsSummaryGeneration(session.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) {
-          generateSessionSummary({
-            messages: summaryMessages,
-            llmClient: llmForSession(sessionId)
-          }).then(async (result) => {
-            if (result.success && result.summary) {
-              sessionManager2.setSummary(sessionId, result.summary);
-              const updatedSession = sessionManager2.getSession(sessionId);
-              if (updatedSession) {
-                const events2 = eventStore.getEvents(sessionId);
-                const messages = buildMessagesFromStoredEvents(events2);
-                broadcastForSession(sessionId, createSessionStateMessage(updatedSession, messages));
-              }
-              logger.info("Session summary generated", { sessionId, summaryLength: result.summary.length });
-            }
-          }).catch((error) => {
-            logger.warn("Session summary generation failed", { sessionId, error: error instanceof Error ? error.message : error });
-          });
-        }
-      }
-      sessionManager2.setMode(sessionId, message.payload.mode);
-      sendForSession(sessionId, createModeChangedMessage(message.payload.mode, false));
-      const modeEvents = eventStore.getEvents(sessionId);
-      const modeMessages = buildMessagesFromStoredEvents(modeEvents);
-      sendForSession(sessionId, createSessionStateMessage(sessionManager2.getSession(sessionId), modeMessages, message.id));
+      send(createErrorMessage("DEPRECATED", "mode.switch removed. Use REST API: PUT /api/sessions/:id/mode", message.id));
       break;
     }
     case "mode.accept": {
@@ -2930,9 +2605,26 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
         send(createErrorMessage("NO_SESSION", "No active session", message.id));
         return;
       }
-      const session = sessionManager2.requireSession(client.activeSessionId);
+      const session = sessionManager.requireSession(client.activeSessionId);
+      const acceptPayload = message.payload;
       if (session.isRunning) {
-        send(createErrorMessage("ALREADY_RUNNING", "Session is already running", message.id));
+        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;
@@ -2951,7 +2643,7 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
           try {
             for await (const storedEvent of iterator) {
               const serverMsg = storedEventToServerMessage(storedEvent);
-              if (serverMsg && ws.readyState === WebSocket.OPEN) {
+              if (serverMsg && ws.readyState === WebSocket2.OPEN) {
                 ws.send(serializeServerMessage({ ...serverMsg, seq: storedEvent.seq, sessionId: sid }));
               }
             }
@@ -2960,10 +2652,10 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
           }
         })();
       }
-      sessionManager2.setRunning(sessionId, true);
+      sessionManager.setRunning(sessionId, true);
       eventStore.append(sessionId, { type: "running.changed", data: { isRunning: true } });
       sendForSession(sessionId, createSessionRunningMessage(true));
-      const currentSession = sessionManager2.requireSession(sessionId);
+      const currentSession = sessionManager.requireSession(sessionId);
       if (needsSummaryGeneration(currentSession.summary)) {
         const events = eventStore.getEvents(sessionId);
         const nonSystemEvents = events.filter((event) => {
@@ -2973,12 +2665,19 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
         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)
+            llmClient: llmForSession(sessionId),
+            workdir: currentSession.workdir,
+            customInstructions: instructions || void 0,
+            skills
           }).then(async (result) => {
             if (result.success && result.summary) {
-              sessionManager2.setSummary(sessionId, result.summary);
+              sessionManager.setSummary(sessionId, result.summary);
             }
           }).catch((error) => {
             logger.warn("Session summary generation failed", { sessionId, error: error instanceof Error ? error.message : error });
@@ -2989,8 +2688,8 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
       (async () => {
         let controller = null;
         try {
-          sessionManager2.setMode(sessionId, "builder");
-          sessionManager2.setPhase(sessionId, "build");
+          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();
@@ -3000,19 +2699,19 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
             existingController.abort();
           }
           activeAgents.set(sessionId, controller);
-          const acceptPayload = message.payload;
-          const acceptAttachments = acceptPayload?.attachments;
-          const hasAcceptContent = acceptPayload?.content && typeof acceptPayload.content === "string" && acceptPayload.content.trim();
+          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: sessionManager2,
+            sessionManager,
             sessionId,
             llmClient: llmForSession(sessionId),
             statsIdentity: statsForSession(sessionId),
             injectBuilderKickoff: !hasAcceptMessage,
-            ...acceptPayload?.workflowId ? { workflowId: acceptPayload.workflowId } : {},
-            ...hasAcceptMessage ? { userMessage: { content: hasAcceptContent ? acceptPayload.content : "", ...hasAcceptAttachments ? { attachments: acceptAttachments } : {} } } : {},
+            ...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
@@ -3031,7 +2730,7 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
           });
           const errorMsgId = crypto.randomUUID();
           eventStore.append(sessionId, createMessageStartEvent(errorMsgId, "user", `Error: ${error instanceof Error ? error.message : "Unknown error"}`, {
-            ...getCurrentWindowMessageOptions3(sessionId) ?? {},
+            ...getCurrentWindowMessageOptions2(sessionId) ?? {},
             isSystemGenerated: true,
             messageKind: "correction"
           }));
@@ -3042,14 +2741,14 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
             return;
           }
           activeAgents.delete(sessionId);
-          const completionMsgs = sessionManager2.drainCompletionMessages(sessionId);
+          const completionMsgs = sessionManager.drainCompletionMessages(sessionId);
           const nextCompletion = completionMsgs[0];
           if (nextCompletion) {
             for (const remaining of completionMsgs.slice(1)) {
-              sessionManager2.queueMessage(sessionId, "completion", remaining.content, remaining.attachments);
+              sessionManager.queueMessage(sessionId, "completion", remaining.content, remaining.attachments);
             }
-            sendForSession(sessionId, createQueueStateMessage(sessionManager2.getQueueState(sessionId)));
-            const userMessage = sessionManager2.addMessage(sessionId, {
+            sendForSession(sessionId, createQueueStateMessage(sessionManager.getQueueState(sessionId)));
+            const userMessage = sessionManager.addMessage(sessionId, {
               role: "user",
               content: nextCompletion.content,
               ...nextCompletion.attachments ? { attachments: nextCompletion.attachments } : {}
@@ -3060,10 +2759,28 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
             startTurnWithCompletionChain(sessionId, newController);
             return;
           }
-          sessionManager2.clearMessageQueue(sessionId);
-          sessionManager2.setRunning(sessionId, false);
+          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 = sessionManager2.getContextState(sessionId);
+          const contextState = sessionManager.getContextState(sessionId);
           sendForSession(sessionId, createContextStateMessage(contextState));
         }
       })();
@@ -3073,17 +2790,7 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
     // Criteria Editing
     // =========================================================================
     case "criteria.edit": {
-      if (!client.activeSessionId) {
-        send(createErrorMessage("NO_SESSION", "No active session", message.id));
-        return;
-      }
-      if (!isCriteriaEditPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid criteria.edit payload", message.id));
-        return;
-      }
-      sessionManager2.setCriteria(client.activeSessionId, message.payload.criteria);
-      sendForSession(client.activeSessionId, createCriteriaUpdatedMessage(message.payload.criteria));
-      send({ type: "ack", payload: {}, id: message.id });
+      send(createErrorMessage("DEPRECATED", "criteria.edit removed. Use REST API: PUT /api/sessions/:id/criteria", message.id));
       break;
     }
     // =========================================================================
@@ -3094,31 +2801,32 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
         send(createErrorMessage("NO_SESSION", "No active session", message.id));
         return;
       }
-      const session = sessionManager2.requireSession(client.activeSessionId);
+      const session = sessionManager.requireSession(client.activeSessionId);
       const sessionId = client.activeSessionId;
       if (session.isRunning) {
         send(createErrorMessage("SESSION_RUNNING", "Cannot compact while session is running", message.id));
         return;
       }
-      const contextState = sessionManager2.getContextState(sessionId);
+      const contextState = sessionManager.getContextState(sessionId);
       const tokensBefore = contextState.currentTokens;
       send({ type: "ack", payload: {}, id: message.id });
       (async () => {
         try {
           await performManualContextCompaction({
-            sessionManager: sessionManager2,
+            sessionManager,
             sessionId,
             llmClient: llmForSession(sessionId),
             statsIdentity: statsForSession(sessionId),
             tokenCountAtClose: tokensBefore
           });
-          const newContextState = sessionManager2.getContextState(sessionId);
+          const newContextState = sessionManager.getContextState(sessionId);
           sendForSession(sessionId, createContextStateMessage(newContextState));
-          const updatedSession = sessionManager2.requireSession(sessionId);
+          const updatedSession = sessionManager.requireSession(sessionId);
           const compactEventStore = getEventStore();
           const compactEvents = compactEventStore.getEvents(sessionId);
           const compactMessages = buildMessagesFromStoredEvents(compactEvents);
-          sendForSession(sessionId, createSessionStateMessage(updatedSession, compactMessages));
+          const pendingConfirmations = foldPendingConfirmations(compactEvents);
+          sendForSession(sessionId, createSessionStateMessage(updatedSession, compactMessages, pendingConfirmations));
         } catch (error) {
           logger.error("Compaction failed", { error, sessionId });
           sendForSession(sessionId, createChatErrorMessage(
@@ -3137,9 +2845,26 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
         send(createErrorMessage("NO_SESSION", "No active session", message.id));
         return;
       }
-      const session = sessionManager2.requireSession(client.activeSessionId);
+      const session = sessionManager.requireSession(client.activeSessionId);
       if (session.isRunning) {
-        send(createErrorMessage("ALREADY_RUNNING", "Session is already running", message.id));
+        const launchPayload2 = message.payload;
+        const content = launchPayload2?.content ?? "";
+        const attachments = launchPayload2?.attachments;
+        const workflowId = launchPayload2?.workflowId;
+        let fullContent = content;
+        if (workflowId) {
+          const workflowInfo = `// Workflow: ${workflowId}`;
+          fullContent = content ? `${workflowInfo}
+
+${content}` : workflowInfo;
+        }
+        sessionManager.queueMessage(client.activeSessionId, "asap", fullContent, attachments, "workflow-launch");
+        const queueState = sessionManager.getQueueState(client.activeSessionId);
+        send({
+          type: "queue.state",
+          payload: { success: true, queueState },
+          id: message.id
+        });
         return;
       }
       if (session.mode !== "builder") {
@@ -3155,15 +2880,15 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
       const sessionId = client.activeSessionId;
       if (session.phase === "blocked") {
         logger.info("User launched runner - resetting blocked state", { sessionId });
-        sessionManager2.setPhase(sessionId, "build");
-        sessionManager2.resetAllCriteriaAttempts(sessionId);
+        sessionManager.setPhase(sessionId, "build");
+        sessionManager.resetAllCriteriaAttempts(sessionId);
       }
       const launchPayload = message.payload;
       const launchAttachments = launchPayload?.attachments;
       const hasUserContent = launchPayload?.content && typeof launchPayload.content === "string" && launchPayload.content.trim();
       const hasUserAttachments = launchAttachments && launchAttachments.length > 0;
       const hasUserMessage = hasUserContent || hasUserAttachments;
-      sessionManager2.setRunning(sessionId, true);
+      sessionManager.setRunning(sessionId, true);
       sendForSession(sessionId, createSessionRunningMessage(true));
       const controller = new AbortController();
       const existingController = activeAgents.get(sessionId);
@@ -3176,7 +2901,7 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
       ensureEventStoreSubscription(sessionId);
       logger.info("Runner launching", { sessionId, pendingCriteria: pendingCriteria.length });
       runOrchestrator({
-        sessionManager: sessionManager2,
+        sessionManager,
         sessionId,
         llmClient: llmForSession(sessionId),
         statsIdentity: statsForSession(sessionId),
@@ -3196,14 +2921,32 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
           return;
         }
         activeAgents.delete(sessionId);
-        const completionMsgs = sessionManager2.drainCompletionMessages(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)) {
-            sessionManager2.queueMessage(sessionId, "completion", remaining.content, remaining.attachments);
+            sessionManager.queueMessage(sessionId, "completion", remaining.content, remaining.attachments);
           }
-          sendForSession(sessionId, createQueueStateMessage(sessionManager2.getQueueState(sessionId)));
-          const userMessage = sessionManager2.addMessage(sessionId, {
+          sendForSession(sessionId, createQueueStateMessage(sessionManager.getQueueState(sessionId)));
+          const userMessage = sessionManager.addMessage(sessionId, {
             role: "user",
             content: nextCompletion.content,
             ...nextCompletion.attachments ? { attachments: nextCompletion.attachments } : {}
@@ -3214,8 +2957,8 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
           startTurnWithCompletionChain(sessionId, newController);
           return;
         }
-        sessionManager2.clearMessageQueue(sessionId);
-        sessionManager2.setRunning(sessionId, false);
+        sessionManager.clearMessageQueue(sessionId);
+        sessionManager.setRunning(sessionId, false);
       });
       break;
     }
@@ -3223,24 +2966,31 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
     // Path Confirmation
     // =========================================================================
     case "path.confirm": {
+      send(createErrorMessage("DEPRECATED", "path.confirm removed. Use REST API: POST /api/sessions/:id/confirm-path", message.id));
+      break;
+    }
+    // =========================================================================
+    // Ask User
+    // =========================================================================
+    case "ask.answer": {
       if (!client.activeSessionId) {
         send(createErrorMessage("NO_SESSION", "No active session", message.id));
         return;
       }
-      if (!isPathConfirmPayload(message.payload)) {
-        send(createErrorMessage("INVALID_PAYLOAD", "Invalid path.confirm payload", message.id));
+      if (!isAskAnswerPayload(message.payload)) {
+        send(createErrorMessage("INVALID_PAYLOAD", "Invalid ask.answer payload", message.id));
         return;
       }
-      const { callId, approved } = message.payload;
-      const result = providePathConfirmation(callId, approved);
-      if (!result.found) {
-        send(createErrorMessage("NOT_FOUND", "No pending path confirmation with that ID", message.id));
+      const { callId, answer } = message.payload;
+      const found = provideAnswer(callId, answer);
+      if (!found) {
+        send(createErrorMessage("NOT_FOUND", "No pending question with that ID", message.id));
         return;
       }
-      logger.debug("Path confirmation response", {
+      logger.debug("Ask user answer received", {
         sessionId: client.activeSessionId,
         callId,
-        approved
+        answerLength: answer.length
       });
       send({ type: "ack", payload: {}, id: message.id });
       break;
@@ -3252,7 +3002,7 @@ async function handleClientMessage(ws, client, message, config, getLLMClient, ge
 }
 
 // src/server/lsp/server.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { extname } from "path";
 import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node.js";
 var LSP = {
@@ -3314,7 +3064,7 @@ var LspServer = class {
     }
     this.state = "starting";
     try {
-      this.process = spawn2(this.commandPath, this.config.serverArgs, {
+      this.process = spawn3(this.commandPath, this.config.serverArgs, {
         cwd: this.workdir,
         stdio: ["pipe", "pipe", "pipe"],
         env: {
@@ -4299,11 +4049,16 @@ function canCompact(currentTokens, maxTokens) {
 var SessionManager = class {
   events = new EventEmitter();
   activeSessionId = null;
+  providerManager;
+  constructor(providerManager) {
+    this.providerManager = providerManager;
+  }
   // ============================================================================
   // Session Lifecycle
   // ============================================================================
   /**
    * Create a new session. Emits session.initialized event.
+   * Note: maxTokens is no longer stored in the session - it comes from the current model config
    */
   createSession(projectId, title, providerId, providerModel) {
     const project = getProject(projectId);
@@ -4312,8 +4067,8 @@ var SessionManager = class {
     }
     let sessionTitle = title;
     if (!sessionTitle) {
-      const existingSessions = listSessionsByProject(projectId);
-      sessionTitle = `Session ${existingSessions.length + 1}`;
+      const existingSessions = listSessionsByProject(projectId, 1e3, 0);
+      sessionTitle = `Session ${existingSessions.sessions.length + 1}`;
     }
     logger.debug("Creating session", { projectId, workdir: project.workdir, title: sessionTitle });
     const dbSession = createSession(projectId, project.workdir, sessionTitle, providerId, providerModel);
@@ -4351,14 +4106,14 @@ var SessionManager = class {
     return listSessions();
   }
   /**
-   * List sessions for a project.
+   * List sessions for a project with pagination.
    */
-  listSessionsByProject(projectId) {
+  listSessionsByProject(projectId, limit = 20, offset = 0) {
     const project = getProject(projectId);
     if (!project) {
-      return [];
+      return { sessions: [], hasMore: false };
     }
-    return listSessionsByProject(projectId);
+    return listSessionsByProject(projectId, limit, offset);
   }
   /**
    * Delete a session and all its events.
@@ -4387,8 +4142,8 @@ var SessionManager = class {
    */
   deleteAllSessions(projectId, workdir) {
     logger.debug("Deleting all sessions for project", { projectId, workdir });
-    const sessions = listSessionsByProject(projectId);
-    sessions.forEach((session) => {
+    const result = listSessionsByProject(projectId, 1e4, 0);
+    result.sessions.forEach((session) => {
       this.deleteSession(session.id);
     });
   }
@@ -4425,6 +4180,16 @@ var SessionManager = class {
     this.emit({ type: "phase_changed", sessionId, phase });
     return updatedSession;
   }
+  /**
+   * Set danger level. Does NOT emit event - danger level is not part of session state.
+   * Just updates DB and returns updated session.
+   */
+  setDangerLevel(sessionId, dangerLevel) {
+    this.requireSession(sessionId);
+    logger.debug("Setting danger level", { sessionId, dangerLevel });
+    updateSessionDangerLevel(sessionId, dangerLevel);
+    return this.requireSession(sessionId);
+  }
   /**
    * Set session running state. Emits running.changed event.
    */
@@ -4598,17 +4363,18 @@ ${summary}`, {
       contextWindowId: newWindowId,
       isSystemGenerated: true,
       messageKind: "auto-prompt",
-      isCompactionSummary: true
+      isCompactionSummary: true,
+      metadata: { type: "compaction", name: "Compaction", color: "#64748b" }
     });
   }
   /**
    * Set current context size (for token tracking).
    * Emits a context.state event with the real promptTokens from the LLM.
+   * maxTokens comes from providerManager.getCurrentModelContext() - the currently selected model's limit.
    */
   setCurrentContextSize(sessionId, promptTokens) {
-    const config = getRuntimeConfig();
-    const maxTokens = config.context.maxTokens;
-    const state = getSessionState(sessionId);
+    const state = getSessionState(sessionId, this.providerManager.getCurrentModelContext());
+    const maxTokens = this.providerManager.getCurrentModelContext();
     const compactionCount = state?.contextState.compactionCount ?? 0;
     emitContextState(
       sessionId,
@@ -4682,14 +4448,7 @@ ${summary}`, {
     if (!state) {
       return { error: "Session not found" };
     }
-    let actualId = criterion.id;
-    if (state.criteria.some((c) => c.id === criterion.id)) {
-      let suffix = 1;
-      while (state.criteria.some((c) => c.id === `${criterion.id}-${suffix}`)) {
-        suffix++;
-      }
-      actualId = `${criterion.id}-${suffix}`;
-    }
+    const actualId = criterion.id || state.criteria.length.toString();
     const updatedCriteria = [...state.criteria, { ...criterion, id: actualId }];
     emitCriteriaSet(sessionId, updatedCriteria);
     return { criteria: updatedCriteria, actualId };
@@ -4730,17 +4489,19 @@ ${summary}`, {
   // Message Queue (runtime state, transient while agent is running)
   // ============================================================================
   messageQueues = /* @__PURE__ */ new Map();
-  queueMessage(sessionId, mode, content, attachments) {
+  queueMessage(sessionId, mode, content, attachments, messageKind) {
     const queue = this.messageQueues.get(sessionId) ?? [];
     const msg = {
       queueId: crypto.randomUUID(),
       mode,
       content,
       ...attachments ? { attachments } : {},
+      ...messageKind ? { messageKind } : {},
       queuedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     queue.push(msg);
     this.messageQueues.set(sessionId, queue);
+    this.emit({ type: "queue_added", sessionId, queueId: msg.queueId, mode, content });
     return msg;
   }
   cancelQueuedMessage(sessionId, queueId) {
@@ -4749,6 +4510,7 @@ ${summary}`, {
     const idx = queue.findIndex((m) => m.queueId === queueId);
     if (idx === -1) return false;
     queue.splice(idx, 1);
+    this.emit({ type: "queue_cancelled", sessionId, queueId });
     return true;
   }
   drainAsapMessages(sessionId) {
@@ -4756,6 +4518,9 @@ ${summary}`, {
     if (!queue) return [];
     const asap = queue.filter((m) => m.mode === "asap");
     this.messageQueues.set(sessionId, queue.filter((m) => m.mode !== "asap"));
+    for (const msg of asap) {
+      this.emit({ type: "queue_drained", sessionId, queueId: msg.queueId });
+    }
     return asap;
   }
   drainCompletionMessages(sessionId) {
@@ -4763,11 +4528,18 @@ ${summary}`, {
     if (!queue) return [];
     const completion = queue.filter((m) => m.mode === "completion");
     this.messageQueues.set(sessionId, queue.filter((m) => m.mode !== "completion"));
+    for (const msg of completion) {
+      this.emit({ type: "queue_drained", sessionId, queueId: msg.queueId });
+    }
     return completion;
   }
   getQueueState(sessionId) {
     return this.messageQueues.get(sessionId) ?? [];
   }
+  hasQueuedMessages(sessionId) {
+    const queue = this.messageQueues.get(sessionId);
+    return queue !== void 0 && queue.length > 0;
+  }
   clearMessageQueue(sessionId) {
     this.messageQueues.delete(sessionId);
   }
@@ -4849,12 +4621,34 @@ ${summary}`,
    * Get the current context state for a session.
    */
   getContextState(sessionId) {
-    const state = getSessionState(sessionId);
+    const session = this.getSession(sessionId);
+    const providerManager = this.providerManager;
+    let maxTokens;
+    if (session?.providerId && session.providerModel) {
+      const providers = providerManager.getProviders();
+      const provider = providers.find((p) => p.id === session.providerId);
+      if (provider) {
+        let modelConfig = provider.models.find((m) => m.id === session.providerModel);
+        if (!modelConfig && session.providerModel) {
+          const normalize = (s) => s.toLowerCase().replace(/[-_\s]+/g, "");
+          const sessionModelNormalized = normalize(session.providerModel);
+          modelConfig = provider.models.find((m) => {
+            const modelIdNormalized = normalize(m.id);
+            return modelIdNormalized === sessionModelNormalized || modelIdNormalized.includes(sessionModelNormalized) || sessionModelNormalized.includes(modelIdNormalized);
+          });
+        }
+        maxTokens = modelConfig?.contextWindow ?? providerManager.getCurrentModelContext();
+      } else {
+        maxTokens = providerManager.getCurrentModelContext();
+      }
+    } else {
+      maxTokens = providerManager.getCurrentModelContext();
+    }
+    const state = getSessionState(sessionId, maxTokens);
     if (!state) {
-      const config = getRuntimeConfig();
       return {
         currentTokens: 0,
-        maxTokens: config.context.maxTokens,
+        maxTokens,
         compactionCount: 0,
         dangerZone: false,
         canCompact: false
@@ -4905,7 +4699,8 @@ ${summary}`,
    * Build a full Session object from DB session + EventStore state
    */
   buildSessionFromDb(dbSession) {
-    const eventState = getSessionState(dbSession.id);
+    const maxTokens = this.providerManager.getCurrentModelContext();
+    const eventState = getSessionState(dbSession.id, maxTokens);
     if (!eventState) {
       return {
         ...dbSession,
@@ -4949,12 +4744,10 @@ ${summary}`,
       criteria: eventState.criteria,
       contextWindows: [],
       // Derived from events, not stored separately
-      executionState: null
-      // No longer using execution state
+      executionState: eventState.lastModeWithReminder ? { lastModeWithReminder: eventState.lastModeWithReminder } : null
     };
   }
 };
-var sessionManager = new SessionManager();
 
 // src/server/commands/registry.ts
 import { readdir as readdir2, readFile as readFile2, writeFile as writeFile2, copyFile as copyFile2, mkdir as mkdir2, access as access3, unlink as unlink2 } from "fs/promises";
@@ -5509,8 +5302,10 @@ function createDevServerRoutes() {
   router.get("/logs", (req, res) => {
     const workdir = req.query["workdir"];
     if (!workdir) return res.status(400).json({ error: "workdir required" });
-    const logs = devServerManager.getLogs(workdir);
-    res.json({ logs });
+    const offset = Math.max(0, parseInt(req.query["offset"]) || 0);
+    const limit = Math.max(1, parseInt(req.query["limit"]) || Infinity);
+    const result = devServerManager.getLogsSlice(workdir, offset, limit);
+    res.json({ logs: result.logs, total: result.total, offset, limit });
   });
   router.get("/config", async (req, res) => {
     const workdir = req.query["workdir"];
@@ -5536,6 +5331,44 @@ function createDevServerRoutes() {
   return router;
 }
 
+// src/server/routes/terminals.ts
+import { Router as Router6 } from "express";
+function createTerminalRoutes() {
+  const router = Router6();
+  router.get("/", (_req, res) => {
+    const sessions = terminalManager.getAll();
+    const response = sessions.map((s) => ({
+      id: s.id,
+      workdir: s.workdir
+    }));
+    res.json(response);
+  });
+  router.post("/", (req, res) => {
+    const workdir = req.body?.workdir;
+    const session = terminalManager.create(workdir);
+    res.status(201).json({ id: session.id, workdir: session.workdir });
+  });
+  router.delete("/:id", (req, res) => {
+    const { id } = req.params;
+    const success = terminalManager.kill(id);
+    if (success) {
+      res.status(204).send();
+    } else {
+      res.status(404).json({ error: "Terminal not found" });
+    }
+  });
+  router.get("/:id", (req, res) => {
+    const { id } = req.params;
+    const session = terminalManager.get(id);
+    if (session) {
+      res.json({ id: session.id, workdir: session.workdir });
+    } else {
+      res.status(404).json({ error: "Terminal not found" });
+    }
+  });
+  return router;
+}
+
 // src/server/index.ts
 var __dirname2 = dirname4(fileURLToPath4(import.meta.url));
 async function createServerHandle(config) {
@@ -5548,8 +5381,8 @@ async function createServerHandle(config) {
   await ensureDefaultCommands(configDir);
   await ensureDefaultAgents(configDir);
   await ensureDefaultWorkflows(configDir);
-  const sessionManager2 = new SessionManager();
   const providerManager = createProviderManager(config);
+  const sessionManager = new SessionManager(providerManager);
   const useMock = process.env["OPENFOX_MOCK_LLM"] === "true";
   const getMockClient = useMock ? createMockLLMClient : null;
   const getLLMClient = () => getMockClient ? getMockClient() : providerManager.getLLMClient();
@@ -5584,8 +5417,19 @@ async function createServerHandle(config) {
         logger.warn("Could not auto-detect model, using config", { model: config.llm.model });
       }
     }
+    const activeProvider = providerManager.getActiveProvider();
+    if (activeProvider) {
+      await providerManager.refreshProviderModels(activeProvider.id).catch((err) => {
+        logger.debug("Startup model refetch failed", {
+          providerId: activeProvider.id,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    }
   }
-  initLLM().catch((err) => logger.error("LLM initialization failed", { error: err instanceof Error ? err.message : String(err) }));
+  initLLM().catch(
+    (err) => logger.error("LLM initialization failed", { error: err instanceof Error ? err.message : String(err) })
+  );
   const toolRegistry = createToolRegistry();
   const app = express();
   app.use(cors());
@@ -5594,39 +5438,317 @@ async function createServerHandle(config) {
     res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   });
   app.get("/api/tools", (_req, res) => {
-    res.json({ tools: toolRegistry.tools.map((t) => t.name) });
+    const tools = toolRegistry.tools.map((t) => ({
+      name: t.name,
+      actions: t.permittedActions || []
+    }));
+    res.json({ tools });
+  });
+  app.get("/api/projects", async (_req, res) => {
+    const { listProjects } = await import("./projects-GSMMEVSO.js");
+    const projects = listProjects();
+    res.json({ projects });
+  });
+  app.post("/api/projects", async (req, res) => {
+    const { name, workdir } = req.body;
+    if (!name || !workdir) {
+      return res.status(400).json({ error: "name and workdir are required" });
+    }
+    const { createDirectoryWithGit } = await import("./project-creator-KAQXMZCT.js");
+    const project = await createDirectoryWithGit(name, workdir);
+    res.status(201).json({ project });
+  });
+  app.get("/api/projects/:id", async (req, res) => {
+    const { getProject: getProject2 } = await import("./projects-GSMMEVSO.js");
+    const project = getProject2(req.params.id);
+    if (!project) {
+      return res.status(404).json({ error: "Project not found" });
+    }
+    res.json({ project });
+  });
+  app.put("/api/projects/:id", async (req, res) => {
+    const { updateProject } = await import("./projects-GSMMEVSO.js");
+    const { name, customInstructions } = req.body;
+    const updates = {};
+    if (name !== void 0) updates.name = name;
+    if (customInstructions !== void 0) updates.customInstructions = customInstructions;
+    const updated = updateProject(req.params.id, updates);
+    if (!updated) {
+      return res.status(404).json({ error: "Project not found" });
+    }
+    res.json({ project: updated });
+  });
+  app.delete("/api/projects/:id", async (req, res) => {
+    const { getProject: getProject2, deleteProject } = await import("./projects-GSMMEVSO.js");
+    const project = getProject2(req.params.id);
+    if (!project) {
+      return res.status(404).json({ error: "Project not found" });
+    }
+    deleteProject(req.params.id);
+    res.json({ success: true });
+  });
+  app.get("/api/sessions", async (req, res) => {
+    const { getRecentUserPromptsForSession } = await import("./events-G6CKHDNZ.js");
+    const projectId = req.query["projectId"];
+    const limit = Math.min(parseInt(req.query["limit"]) || 20, 100);
+    const offset = parseInt(req.query["offset"]) || 0;
+    let sessions;
+    let hasMore = false;
+    if (projectId) {
+      const result = sessionManager.listSessionsByProject(projectId, limit, offset);
+      sessions = result.sessions;
+      hasMore = result.hasMore;
+    } else {
+      sessions = sessionManager.listSessions();
+    }
+    const sessionsWithPrompts = sessions.map((session) => ({
+      ...session,
+      recentUserPrompts: getRecentUserPromptsForSession(session.id, 10)
+    }));
+    res.json({ sessions: sessionsWithPrompts, hasMore });
   });
   app.post("/api/sessions", async (req, res) => {
-    const { workdir, title } = req.body;
-    const session = sessionManager2.createSession(workdir, title);
+    const { projectId, title } = req.body;
+    if (!projectId) {
+      return res.status(400).json({ error: "projectId is required" });
+    }
+    const project = sessionManager.getProject(projectId);
+    if (!project) {
+      return res.status(404).json({ error: "Project not found" });
+    }
+    const { providerId, model } = parseDefaultModelSelection(config.defaultModelSelection);
+    const session = sessionManager.createSession(projectId, title, providerId ?? null, model ?? null);
     res.status(201).json({ session });
   });
-  app.get("/api/sessions/:id", (req, res) => {
-    const session = sessionManager2.getSession(req.params.id);
+  app.get("/api/sessions/:id", async (req, res) => {
+    const { getEventStore: getEventStore2 } = await import("./events-G6CKHDNZ.js");
+    const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2 } = await import("./folding-O52L65VN.js");
+    const session = sessionManager.getSession(req.params.id);
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
-    res.json({ session });
+    const eventStore = getEventStore2();
+    const events = eventStore.getEvents(req.params.id);
+    const messages = buildMessagesFromStoredEvents2(events);
+    const contextState = sessionManager.getContextState(req.params.id);
+    const queueState = sessionManager.getQueueState(req.params.id);
+    res.json({ session, messages, contextState, queueState });
   });
   app.delete("/api/sessions/:id", (req, res) => {
-    sessionManager2.deleteSession(req.params["id"]);
+    const session = sessionManager.getSession(req.params["id"]);
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+    sessionManager.deleteSession(req.params["id"]);
     res.json({ success: true });
   });
   app.delete("/api/projects/:projectId/sessions", (req, res) => {
     const projectId = req.params["projectId"];
-    const project = sessionManager2.getProject(projectId);
+    const project = sessionManager.getProject(projectId);
     if (!project) {
       return res.status(404).json({ error: "Project not found" });
     }
-    sessionManager2.deleteAllSessions(projectId, project.workdir);
+    sessionManager.deleteAllSessions(projectId, project.workdir);
+    res.json({ success: true });
+  });
+  app.post("/api/sessions/:id/provider", async (req, res) => {
+    const { getEventStore: getEventStore2 } = await import("./events-G6CKHDNZ.js");
+    const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2 } = await import("./folding-O52L65VN.js");
+    const sessionId = req.params.id;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+    const { providerId, model } = req.body;
+    if (!providerId) {
+      return res.status(400).json({ error: "providerId is required" });
+    }
+    sessionManager.setSessionProvider(sessionId, providerId, model ?? "auto");
+    const { loadGlobalConfig, saveGlobalConfig, setDefaultModelSelection } = await import("./config-GIFCEJDU.js");
+    const globalConfig = await loadGlobalConfig(config.mode ?? "production");
+    const updatedConfig = setDefaultModelSelection(globalConfig, providerId, model ?? "auto");
+    await saveGlobalConfig(config.mode ?? "production", updatedConfig);
+    config.defaultModelSelection = updatedConfig.defaultModelSelection;
+    const contextState = sessionManager.getContextState(sessionId);
+    const eventStore = getEventStore2();
+    const events = eventStore.getEvents(sessionId);
+    const messages = buildMessagesFromStoredEvents2(events);
+    const updatedSession = sessionManager.getSession(sessionId);
+    res.json({ session: updatedSession, messages, contextState });
+  });
+  app.put("/api/sessions/:id/criteria", async (req, res) => {
+    const sessionId = req.params.id;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+    const { criteria } = req.body;
+    if (!Array.isArray(criteria)) {
+      return res.status(400).json({ error: "criteria is required and must be an array" });
+    }
+    sessionManager.setCriteria(sessionId, criteria);
+    res.json({ success: true });
+  });
+  app.put("/api/sessions/:id/mode", async (req, res) => {
+    const { getEventStore: getEventStore2 } = await import("./events-G6CKHDNZ.js");
+    const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2 } = await import("./folding-O52L65VN.js");
+    const sessionId = req.params.id;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+    const { mode } = req.body;
+    if (!mode || !["planner", "builder"].includes(mode)) {
+      return res.status(400).json({ error: 'mode is required and must be "planner" or "builder"' });
+    }
+    sessionManager.setMode(sessionId, mode);
+    const eventStore = getEventStore2();
+    eventStore.append(sessionId, { type: "mode.changed", data: { mode, auto: false } });
+    const events = eventStore.getEvents(sessionId);
+    const messages = buildMessagesFromStoredEvents2(events);
+    const updatedSession = sessionManager.getSession(sessionId);
+    res.json({ session: updatedSession, messages });
+  });
+  app.put("/api/sessions/:id/danger-level", async (req, res) => {
+    const sessionId = req.params.id;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+    const { dangerLevel } = req.body;
+    if (!dangerLevel || !["normal", "dangerous"].includes(dangerLevel)) {
+      return res.status(400).json({ error: 'dangerLevel is required and must be "normal" or "dangerous"' });
+    }
+    sessionManager.setDangerLevel(sessionId, dangerLevel);
+    const updatedSession = sessionManager.getSession(sessionId);
+    res.json({ session: updatedSession });
+  });
+  app.post("/api/sessions/:id/confirm-path", async (req, res) => {
+    const sessionId = req.params.id;
+    const { callId, approved, alwaysAllow } = req.body;
+    if (!callId || approved === void 0) {
+      return res.status(400).json({ error: "callId and approved are required" });
+    }
+    const { providePathConfirmation: providePathConfirmation2 } = await import("./tools-SGBQE736.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-G6CKHDNZ.js");
+    const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2, foldPendingConfirmations: foldPendingConfirmations2 } = await import("./folding-O52L65VN.js");
+    const { createSessionStateMessage: createSessionStateMessage2 } = await import("./protocol-WQENDK72.js");
+    const eventStore = getEventStore2();
+    const events = eventStore.getEvents(sessionId);
+    const messages = buildMessagesFromStoredEvents2(events);
+    const pendingConfirmations = foldPendingConfirmations2(events);
+    const session = sessionManager.getSession(sessionId);
+    if (session) {
+      const stateMsg = createSessionStateMessage2(session, messages, pendingConfirmations);
+      wssExports.broadcastForSession(sessionId, { ...stateMsg, sessionId });
+    }
+    res.json({ success: true });
+  });
+  app.post("/api/sessions/:id/answer", async (req, res) => {
+    const sessionId = req.params.id;
+    const { callId, answer } = req.body;
+    if (!callId || !answer) {
+      return res.status(400).json({ error: "callId and answer are required" });
+    }
+    const { provideAnswer: provideAnswer2 } = await import("./tools-SGBQE736.js");
+    const found = provideAnswer2(callId, answer);
+    if (!found) {
+      return res.status(404).json({ error: "No pending question with that ID" });
+    }
+    res.json({ success: true });
+  });
+  app.post("/api/sessions/:id/message", (req, res) => {
+    const sessionId = req.params.id;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+    const { content, attachments, messageKind } = req.body;
+    if (!content?.trim()) {
+      return res.status(400).json({ error: "content is required" });
+    }
+    sessionManager.queueMessage(sessionId, "asap", content, attachments, messageKind);
+    res.json({ success: true, queueState: sessionManager.getQueueState(sessionId) });
+  });
+  app.delete("/api/sessions/:id/queue/:queueId", (req, res) => {
+    const sessionId = req.params.id;
+    const { queueId } = req.params;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+    sessionManager.cancelQueuedMessage(sessionId, queueId);
+    res.json({ success: true, queueState: sessionManager.getQueueState(sessionId) });
+  });
+  app.post("/api/sessions/:id/stop", async (req, res) => {
+    const sessionId = req.params.id;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+    const { stopSessionExecution } = await import("./chat-handler-T7SLWZ4E.js");
+    const { cancelQuestionsForSession: cancelQuestionsForSession2, cancelPathConfirmationsForSession: cancelPathConfirmationsForSession2 } = await import("./tools-SGBQE736.js");
+    stopSessionExecution(sessionId, sessionManager);
+    abortSession(sessionId);
+    cancelQuestionsForSession2(sessionId, "Session stopped by user");
+    cancelPathConfirmationsForSession2(sessionId, "Session stopped by user");
+    sessionManager.clearMessageQueue(sessionId);
+    const eventStore = (await import("./events-G6CKHDNZ.js")).getEventStore();
+    eventStore.append(sessionId, { type: "running.changed", data: { isRunning: false } });
     res.json({ success: true });
   });
+  app.post("/api/sessions/:id/chat", async (req, res) => {
+    const sessionId = req.params.id;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+    const { content, attachments, messageKind, isSystemGenerated } = req.body;
+    if (!content) {
+      return res.status(400).json({ error: "content is required" });
+    }
+    if (session.isRunning) {
+      return res.status(409).json({ error: "Session is already running" });
+    }
+    res.json({ accepted: true, sessionId });
+  });
+  app.post("/api/sessions/:id/continue", async (req, res) => {
+    const sessionId = req.params.id;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+    if (session.isRunning) {
+      return res.status(409).json({ error: "Session is already running" });
+    }
+    res.json({ accepted: true });
+  });
+  app.get("/api/settings/:key", async (req, res) => {
+    const { getSetting } = await import("./settings-NCLN4JDZ.js");
+    const key = req.params.key;
+    const value = getSetting(key);
+    res.json({ key, value });
+  });
+  app.put("/api/settings/:key", async (req, res) => {
+    const { setSetting } = await import("./settings-NCLN4JDZ.js");
+    const key = req.params.key;
+    const { value } = req.body;
+    if (value === void 0) {
+      return res.status(400).json({ error: "value is required" });
+    }
+    setSetting(key, value);
+    res.json({ key, value });
+  });
   app.get("/api/config", (_req, res) => {
     const llmClient = getLLMClient();
     const activeProvider = providerManager.getActiveProvider();
     res.json({
       model: llmClient.getModel(),
-      maxContext: config.context.maxTokens,
+      maxContext: providerManager.getCurrentModelContext(),
       llmUrl: activeProvider?.url ?? config.llm.baseUrl,
       llmStatus: getLlmStatus(),
       backend: llmClient.getBackend(),
@@ -5646,10 +5768,20 @@ async function createServerHandle(config) {
       const detected = await detectModel(baseUrl);
       if (detected) {
         llmClient.setModel(detected);
-        return res.json({ model: detected, source: "detected", llmStatus: getLlmStatus(), backend: llmClient.getBackend() });
+        return res.json({
+          model: detected,
+          source: "detected",
+          llmStatus: getLlmStatus(),
+          backend: llmClient.getBackend()
+        });
       }
     }
-    res.json({ model: llmClient.getModel(), source: "cached", llmStatus: getLlmStatus(), backend: llmClient.getBackend() });
+    res.json({
+      model: llmClient.getModel(),
+      source: "cached",
+      llmStatus: getLlmStatus(),
+      backend: llmClient.getBackend()
+    });
   });
   app.get("/api/providers", (_req, res) => {
     const providers = providerManager.getProviders().map((p) => ({
@@ -5674,7 +5806,7 @@ async function createServerHandle(config) {
       return res.status(400).json({ error: result.error });
     }
     const llmClient = getLLMClient();
-    const { loadGlobalConfig, saveGlobalConfig, setDefaultModelSelection } = await import("./config-BMXSDOZB.js");
+    const { loadGlobalConfig, saveGlobalConfig, setDefaultModelSelection } = await import("./config-GIFCEJDU.js");
     const globalConfig = await loadGlobalConfig(config.mode ?? "production");
     const updatedConfig = setDefaultModelSelection(globalConfig, id, llmClient.getModel());
     await saveGlobalConfig(config.mode ?? "production", updatedConfig);
@@ -5685,12 +5817,65 @@ async function createServerHandle(config) {
       backend: llmClient.getBackend()
     });
   });
+  app.post("/api/providers/:id/models/:modelId", async (req, res) => {
+    const { id, modelId } = req.params;
+    const body = req.body;
+    if (!body.contextWindow) {
+      return res.status(400).json({ error: "contextWindow is required" });
+    }
+    const result = await providerManager.updateModelContext(id, modelId, body.contextWindow);
+    if (!result.success) {
+      return res.status(400).json({ error: result.error });
+    }
+    const { loadGlobalConfig, saveGlobalConfig } = await import("./config-GIFCEJDU.js");
+    const globalConfig = await loadGlobalConfig(config.mode ?? "production");
+    const updatedProviders = providerManager.getProviders();
+    const updatedConfig = {
+      ...globalConfig,
+      providers: updatedProviders,
+      activeProviderId: providerManager.getActiveProviderId(),
+      defaultModelSelection: providerManager.getActiveProviderId() ? `${providerManager.getActiveProviderId()}/${providerManager.getCurrentModel()}` : void 0
+    };
+    await saveGlobalConfig(config.mode ?? "production", updatedConfig);
+    let contextState = null;
+    const sessions = sessionManager.listSessions();
+    if (sessions.length > 0) {
+      for (const session of sessions) {
+        const sessionProviderId = session.providerId || providerManager.getActiveProviderId();
+        if (sessionProviderId === id) {
+          contextState = sessionManager.getContextState(session.id);
+          break;
+        }
+      }
+    }
+    res.json({
+      success: true,
+      providerId: id,
+      modelId,
+      contextWindow: body.contextWindow,
+      contextState
+    });
+  });
+  app.post("/api/providers/:id/refresh", async (req, res) => {
+    const { id } = req.params;
+    const result = await providerManager.refreshProviderModels(id);
+    if (!result.success) {
+      return res.status(400).json({ error: result.error });
+    }
+    const updatedProvider = providerManager.getProviders().find((p) => p.id === id);
+    res.json({
+      success: true,
+      providerId: id,
+      models: updatedProvider?.models ?? []
+    });
+  });
   app.use("/api/skills", createSkillRoutes(configDir));
   app.use("/api/commands", createCommandRoutes(configDir));
   app.use("/api/agents", createAgentRoutes(configDir));
   app.use("/api/workflows", createWorkflowRoutes(configDir, config));
   app.use("/api/dev-server", createDevServerRoutes());
-  const { getCurrentBranch } = await import("./branch.api-WDHKZJS6.js");
+  app.use("/api/terminals", createTerminalRoutes());
+  const { getCurrentBranch } = await import("./branch.api-XADFZZAA.js");
   app.get("/api/branch", async (req, res) => {
     await getCurrentBranch(req, res);
   });
@@ -5756,11 +5941,14 @@ async function createServerHandle(config) {
         res.status(404).send("Not found");
       });
     });
-    app.use("/sounds", express.static(join4(webDir, "public", "sounds"), {
-      setHeaders: (res) => {
-        res.set("Content-Type", "audio/mpeg");
-      }
-    }));
+    app.use(
+      "/sounds",
+      express.static(join4(webDir, "public", "sounds"), {
+        setHeaders: (res) => {
+          res.set("Content-Type", "audio/mpeg");
+        }
+      })
+    );
     app.get("/*path", (req, res) => {
       if (req.path.startsWith("/api/")) {
         return;
@@ -5774,13 +5962,16 @@ async function createServerHandle(config) {
   }
   if (!isDev) {
     const distWebDir = resolve(__dirname2, "web");
-    app.use("/assets", express.static(join4(distWebDir, "assets"), {
-      setHeaders: (res, filepath) => {
-        if (filepath.endsWith(".css")) {
-          res.set("Content-Type", "text/css");
+    app.use(
+      "/assets",
+      express.static(join4(distWebDir, "assets"), {
+        setHeaders: (res, filepath) => {
+          if (filepath.endsWith(".css")) {
+            res.set("Content-Type", "text/css");
+          }
         }
-      }
-    }));
+      })
+    );
     app.get("/fox.svg", (_req, res) => {
       readFile3(join4(distWebDir, "fox.svg")).then((content) => {
         res.set("Content-Type", "image/svg+xml");
@@ -5789,11 +5980,14 @@ async function createServerHandle(config) {
         res.status(404).send("Not found");
       });
     });
-    app.use("/sounds", express.static(join4(distWebDir, "sounds"), {
-      setHeaders: (res) => {
-        res.set("Content-Type", "audio/mpeg");
-      }
-    }));
+    app.use(
+      "/sounds",
+      express.static(join4(distWebDir, "sounds"), {
+        setHeaders: (res) => {
+          res.set("Content-Type", "audio/mpeg");
+        }
+      })
+    );
     app.get("/", (_req, res) => {
       readFile3(join4(distWebDir, "index.html"), "utf-8").then((content) => res.send(content)).catch(() => {
         res.status(404).send("Web UI not built. Run `npm run build:web`");
@@ -5809,10 +6003,35 @@ async function createServerHandle(config) {
     });
   }
   const httpServer = createHttpServer(app);
-  const wss = createWebSocketServer(httpServer, config, getLLMClient, () => providerManager.getActiveProvider(), toolRegistry, sessionManager2, providerManager);
+  const wssExports = createWebSocketServer(
+    httpServer,
+    config,
+    getLLMClient,
+    () => providerManager.getActiveProvider(),
+    sessionManager,
+    providerManager
+  );
+  const wss = wssExports.wss;
+  const { QueueProcessor } = await import("./processor-KLHKDILM.js");
+  const queueProcessor = new QueueProcessor({
+    sessionManager,
+    providerManager,
+    getLLMClient,
+    getActiveProvider: () => providerManager.getActiveProvider(),
+    broadcastForSession: wssExports.broadcastForSession
+  });
+  queueProcessor.start();
+  const abortSession = (sessionId) => {
+    const aborted = wssExports.abortSession(sessionId) || queueProcessor.abortSession(sessionId);
+    if (aborted) {
+      sessionManager.setRunning(sessionId, false);
+      wssExports.broadcastForSession(sessionId, { type: "session.running", payload: { isRunning: false } });
+    }
+    return aborted;
+  };
   return {
     httpServer,
-    ctx: { config, sessionManager: sessionManager2, llmClient: getLLMClient(), toolRegistry, providerManager },
+    ctx: { config, sessionManager, llmClient: getLLMClient(), toolRegistry, providerManager },
     start: (port) => new Promise((resolve2, reject) => {
       const listenPort = port ?? config.server.port;
       const host = config.server.host;
@@ -5863,4 +6082,4 @@ export {
   createServerHandle,
   createServer
 };
-//# sourceMappingURL=chunk-3WOUSUW7.js.map
+//# sourceMappingURL=chunk-RAZQTQK2.js.map