openfox 2.0.129 → 2.0.131

package/dist/{chunk-ZXWJ6JTL.js → chunk-6MUSEPV7.js}

@@ -1,13 +1,21 @@
+import {
+  projectSessionStatus
+} from "./chunk-T3S5MTMD.js";
+import {
+  openFolder
+} from "./chunk-WLJJRX22.js";
 import {
   McpOAuthProvider,
   setMcpOAuthServerPort
-} from "./chunk-RSB4AR2A.js";
+} from "./chunk-DQTN4B33.js";
 import {
+  readMcpOAuthEntry,
   setMcpOAuthStoreMode,
   setMcpOAuthStorePath
 } from "./chunk-IJ53Y77N.js";
 import {
   createWebSocketServer,
+  currentSessionToken,
   getAuthConfig,
   hasPassword,
   isValidToken,
@@ -16,10 +24,10 @@ import {
   terminalManager,
   tokenFromPassword,
   verifyPassword
-} from "./chunk-MYNNMV75.js";
+} from "./chunk-7LGMQ5KS.js";
 import {
   TEMPLATE_VARIABLES
-} from "./chunk-2COZT3YI.js";
+} from "./chunk-RQPHGBWI.js";
 import {
   createToolRegistry,
   devServerManager,
@@ -28,42 +36,13 @@ import {
   getBuiltInToolNames,
   resolveLLMClientForAgent,
   setAgentModelOverride,
+  setMcpBootstrapForTools,
   setMcpConfigMode,
   setMcpConfigPath,
   setMcpManagerForTools,
   setMcpTools,
   setNotifyMcpServersChanged
-} from "./chunk-L24A6GZ7.js";
-import {
-  deleteOwnedSkill,
-  deleteProjectSkill,
-  deleteSkill,
-  findSkillById,
-  getDefaultSkillIds,
-  isDefaultSkill,
-  isSkillEnabled,
-  loadAllSkills,
-  loadAllSkillsWithDiagnostics,
-  loadDefaultSkills,
-  loadProjectSkills,
-  loadUserSkills,
-  saveSkill,
-  saveSkillToProject,
-  setSkillEnabled,
-  skillExists,
-  updateOwnedSkill
-} from "./chunk-ZIL6VKLU.js";
-import {
-  openFolder
-} from "./chunk-WLJJRX22.js";
-import {
-  ALWAYS_ALLOWED,
-  ALWAYS_ALLOWED_FOR_SUBAGENTS,
-  TOP_LEVEL_ONLY_TOOLS
-} from "./chunk-GIJUWPRQ.js";
-import {
-  createMcpTools
-} from "./chunk-JE7LW7Y6.js";
+} from "./chunk-5AI3LHRQ.js";
 import {
   checkoutBranchFromSharedSource,
   deleteWorkspace,
@@ -80,7 +59,7 @@ import {
   validateRef,
   validateWorkspaceName,
   workspaceExists
-} from "./chunk-Y3BSBKHY.js";
+} from "./chunk-XE6UC5Z3.js";
 import {
   commandExists,
   deleteCommand,
@@ -93,6 +72,7 @@ import {
   getDefaultWorkflowIds,
   isDefaultCommand,
   isDefaultWorkflow,
+  listAvailableWorkflows,
   loadAllCommands,
   loadAllWorkflows,
   loadDefaultCommands,
@@ -107,12 +87,49 @@ import {
   saveWorkflow,
   saveWorkflowToProject,
   workflowExists
-} from "./chunk-H6YIVK67.js";
+} from "./chunk-ZCFQOC3C.js";
 import {
   getSessionDisabledServers,
   setSessionDisabledServers
-} from "./chunk-7YP4O4XE.js";
+} from "./chunk-TACWRDDC.js";
+import {
+  createMcpTools
+} from "./chunk-JE7LW7Y6.js";
+import {
+  deleteOwnedSkill,
+  deleteProjectSkill,
+  deleteSkill,
+  findSkillById,
+  getDefaultSkillIds,
+  isDefaultSkill,
+  isSkillEnabled,
+  loadAllSkills,
+  loadAllSkillsWithDiagnostics,
+  loadDefaultSkills,
+  loadProjectSkills,
+  loadUserSkills,
+  saveSkill,
+  saveSkillToProject,
+  setSkillEnabled,
+  skillExists,
+  updateOwnedSkill
+} from "./chunk-BKMWZTNO.js";
+import {
+  ALWAYS_ALLOWED,
+  ALWAYS_ALLOWED_FOR_SUBAGENTS,
+  TOP_LEVEL_ONLY_TOOLS
+} from "./chunk-7JVBDBXE.js";
+import {
+  EventEmitter,
+  getPendingQuestionsForSession,
+  provideAnswer
+} from "./chunk-JURM3RPZ.js";
+import {
+  getPendingConfirmationsBySession,
+  providePathConfirmation
+} from "./chunk-Y6ZGHOKM.js";
 import {
+  combineEventsWithSnapshot,
   emitAssistantMessageStart,
   emitContextState,
   emitCriteriaSet,
@@ -128,7 +145,10 @@ import {
   getEventStore,
   getSessionState,
   initEventStore
-} from "./chunk-YJD5A375.js";
+} from "./chunk-FGNJMKDV.js";
+import {
+  buildMessagesFromStoredEvents
+} from "./chunk-M5T4RDPJ.js";
 import {
   clearWorkflowExecution,
   createSession,
@@ -154,27 +174,7 @@ import {
   updateSessionRunning,
   updateSessionWorkdir,
   updateWorkflowExecutionStatus
-} from "./chunk-AQBRI7TM.js";
-import {
-  createContextStateMessage,
-  toClientSession
-} from "./chunk-567L5OJ6.js";
-import {
-  getPathSeparator,
-  isAbsolutePath
-} from "./chunk-66MG44TF.js";
-import {
-  EventEmitter
-} from "./chunk-JURM3RPZ.js";
-import {
-  createProviderManager,
-  detectModel,
-  getLlmStatus,
-  parseDefaultModelSelection
-} from "./chunk-JQMQ4DGC.js";
-import {
-  VERSION
-} from "./chunk-HIRDDCPD.js";
+} from "./chunk-KWAHD2JA.js";
 import {
   agentExists,
   deleteAgent,
@@ -191,47 +191,69 @@ import {
   saveAgent,
   saveAgentToProject,
   setRuntimeConfig
-} from "./chunk-KBESUA3W.js";
+} from "./chunk-ELYHHEYL.js";
 import {
   findFileByInternalId,
   pathExists
 } from "./chunk-OSXPQSLW.js";
 import {
+  createContextStateMessage,
+  toClientSession
+} from "./chunk-P57IBMK4.js";
+import {
+  getPathSeparator,
+  isAbsolutePath
+} from "./chunk-MGEYAYGU.js";
+import {
+  createProviderManager,
+  detectModel,
+  getLlmStatus,
+  parseDefaultModelSelection
+} from "./chunk-ZVHUISW7.js";
+import {
+  buildOpenFoxMcpBootstrap
+} from "./chunk-YNMP647F.js";
+import {
+  VERSION
+} from "./chunk-BMBOSVRM.js";
+import {
+  deleteProject,
   getProject,
   getProjectByWorkdir,
   updateProject
-} from "./chunk-3B232XG4.js";
+} from "./chunk-DPFET73G.js";
 import {
   getModelProfile
-} from "./chunk-7ZMOP5LS.js";
+} from "./chunk-TS5WKTFB.js";
 import {
+  detectBackendFromUrl,
   getBackendDisplayName
-} from "./chunk-PBFGJFGC.js";
+} from "./chunk-UV6IH6HK.js";
 import {
   buildModelsUrl
 } from "./chunk-HNCM3D7Y.js";
 import {
   SessionNotFoundError,
   WorkspaceInUseError
-} from "./chunk-ZFNBATE3.js";
+} from "./chunk-6EZDW4JS.js";
 import {
   deleteSetting,
   getSetting,
   setSetting
-} from "./chunk-N2Q3KYWM.js";
+} from "./chunk-LQKXJPKP.js";
 import {
   initDatabase
-} from "./chunk-OYBUJIC3.js";
+} from "./chunk-JU757HVI.js";
 import {
   isReasoningEffortValue
-} from "./chunk-ISE55FOR.js";
+} from "./chunk-2AI7VYPN.js";
 import {
   logger,
   setLogLevel
 } from "./chunk-K44MW7JJ.js";
 import {
   createServerMessage
-} from "./chunk-ATWOXI52.js";
+} from "./chunk-HCYSGLY2.js";
 import {
   getGlobalConfigDir
 } from "./chunk-CQGTEGKL.js";
@@ -776,6 +798,30 @@ var RULES = [
     tools: [],
     response: "TypeScript is a strongly typed programming language that builds on JavaScript."
   },
+  // Default-workflow completion: the mock must be able to drive the built-in
+  // workflow to $done (finalize/summarize agent steps + sub-agent return_value).
+  {
+    match: /You must call return_value with a summary of your findings/i,
+    tools: [
+      { name: "return_value", arguments: { content: "No issues found in the reviewed changes.", result: "success" } }
+    ],
+    response: "Returning findings summary."
+  },
+  {
+    match: /## Code Review Findings/i,
+    tools: [{ name: "step_done", arguments: {} }],
+    response: "All review findings resolved."
+  },
+  {
+    match: /The step cannot complete because not all review findings/i,
+    tools: [{ name: "step_done", arguments: {} }],
+    response: "Review findings handled."
+  },
+  {
+    match: /Produce a concise summary of what was accomplished/i,
+    tools: [{ name: "step_done", arguments: {} }],
+    response: "Summary produced."
+  },
   {
     match: /.*/,
     tools: [],
@@ -1561,7 +1607,8 @@ var McpManager = class {
           httpOpts.requestInit = { headers };
         }
         if (entry.config.oauth) {
-          httpOpts.authProvider = new McpOAuthProvider(name, entry.config.url);
+          const stored = await readMcpOAuthEntry(name, entry.config.url);
+          httpOpts.authProvider = stored?.tokens ? new McpOAuthProvider(name, entry.config.url) : McpOAuthProvider.forBackgroundProbe(name, entry.config.url);
         }
         transport = new StreamableHTTPClientTransport(new URL(entry.config.url), httpOpts);
       } else {
@@ -1715,7 +1762,11 @@ var McpManager = class {
       }
       const content = result.content;
       const textParts = content.filter((c) => c.type === "text").map((c) => c.text);
-      return { success: !result.isError, output: textParts.join("\n") };
+      const text = textParts.join("\n");
+      if (result.isError) {
+        return { success: false, error: text || "MCP tool call failed" };
+      }
+      return { success: true, output: text };
     } catch (error) {
       return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
@@ -2761,6 +2812,8 @@ var SessionManager = class {
   providerManager;
   dynamicContextChangedStore = /* @__PURE__ */ new Map();
   debugDumpStore = /* @__PURE__ */ new Map();
+  announcedPromptHashStore = /* @__PURE__ */ new Map();
+  announcedToolFingerprintStore = /* @__PURE__ */ new Map();
   warmedUpSessions = /* @__PURE__ */ new Set();
   switchLocks = /* @__PURE__ */ new Map();
   workspaceCreationLocks = /* @__PURE__ */ new Map();
@@ -3027,7 +3080,7 @@ var SessionManager = class {
     updateSessionMessageCount(newSession.id, messages.length);
     const cached2 = getSessionCachedPrompt(originalSessionId);
     if (cached2) {
-      updateSessionCachedPrompt(newSession.id, cached2.systemPrompt, cached2.tools, cached2.hash);
+      updateSessionCachedPrompt(newSession.id, cached2.systemPrompt, cached2.tools, cached2.hash, cached2.promptHash);
       this.markWarmedUp(newSession.id);
     }
     this.emit({ type: "session_updated", session: this.requireSession(newSession.id) });
@@ -3097,6 +3150,8 @@ var SessionManager = class {
     eventStore.deleteSession(id);
     this.messageQueues.delete(id);
     this.warmedUpSessions.delete(id);
+    this.announcedPromptHashStore.delete(id);
+    this.announcedToolFingerprintStore.delete(id);
     deleteSession(id);
     if (this.activeSessionId === id) {
       this.activeSessionId = null;
@@ -3580,7 +3635,7 @@ var SessionManager = class {
     const state = getSessionState(sessionId, this.getCurrentModelContext(sessionId));
     const maxTokens = this.getCurrentModelContext(sessionId);
     const currentTokens = promptTokens + completionTokens;
-    const compactionCount = state?.contextState.compactionCount ?? 0;
+    const compactionCount = subAgentId ? 0 : state?.contextState.compactionCount ?? 0;
     const dynamicContextChanged = this.getDynamicContextChanged(sessionId);
     emitContextState(
       sessionId,
@@ -3819,8 +3874,8 @@ var SessionManager = class {
   resetWarmup(sessionId) {
     this.warmedUpSessions.delete(sessionId);
   }
-  setCachedPrompt(sessionId, systemPrompt, tools, hash) {
-    updateSessionCachedPrompt(sessionId, systemPrompt, tools, hash);
+  setCachedPrompt(sessionId, systemPrompt, tools, hash, promptHash) {
+    updateSessionCachedPrompt(sessionId, systemPrompt, tools, hash, promptHash);
     this.resetWarmup(sessionId);
   }
   getCachedPrompt(sessionId) {
@@ -3839,6 +3894,27 @@ var SessionManager = class {
   getDynamicContextChanged(sessionId) {
     return this.dynamicContextChangedStore.get(sessionId) ?? false;
   }
+  /**
+   * The instructions/skills/model hash last announced to the model via a
+   * system-prompt-change reminder. Drives exactly-once prompt-drift reminders.
+   */
+  getAnnouncedPromptHash(sessionId) {
+    return this.announcedPromptHashStore.get(sessionId);
+  }
+  setAnnouncedPromptHash(sessionId, hash) {
+    this.announcedPromptHashStore.set(sessionId, hash);
+  }
+  /**
+   * The tool fingerprint last announced to the model via a tool-change
+   * reminder. Drives exactly-once tool-drift reminders WITHOUT mutating the
+   * cached prefix (the cached tools stay frozen until a manual rebase).
+   */
+  getAnnouncedToolFingerprint(sessionId) {
+    return this.announcedToolFingerprintStore.get(sessionId);
+  }
+  setAnnouncedToolFingerprint(sessionId, fingerprint) {
+    this.announcedToolFingerprintStore.set(sessionId, fingerprint);
+  }
   /**
    * @deprecated Use addTokensUsed instead
    */
@@ -4748,10 +4824,766 @@ function createWorkflowRoutes(configDir, config3, projectDir) {
   return createCrudRoutes(crudConfig, configDir, projectDir);
 }
 
-// src/server/routes/dev-server.ts
+// src/server/mcp/server/endpoint.ts
 import { Router as Router4 } from "express";
-function createDevServerRoutes() {
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// src/server/mcp/server/tools.ts
+import { z } from "zod";
+var CONTINUE_PROMPT = "Continue working on the acceptance criteria.";
+var MAX_DETAIL_CONTENT_LENGTH_DEFAULT = 400;
+var MIN_DETAIL_CONTENT_LENGTH = 50;
+var MAX_DETAIL_CONTENT_LENGTH_HARD_CAP = 1e4;
+var WAIT_TIMEOUT_SECONDS_DEFAULT = 60;
+var WAIT_TIMEOUT_SECONDS_MIN = 5;
+var WAIT_TIMEOUT_SECONDS_MAX = 600;
+var WAIT_POLL_INTERVAL_MS = 500;
+var WAIT_IDLE_GRACE_MS = 2e3;
+var METADATA_SCHEMAS = {
+  criteria: {
+    description: "Acceptance criteria that drive workflow transitions",
+    fields: {
+      id: "string (auto-generated)",
+      description: "string \u2014 what needs to be done and how to verify it",
+      status: "pending | completed | passed | failed"
+    },
+    defaultStatus: "pending"
+  },
+  todos: {
+    description: "Task tracking items for the builder",
+    fields: {
+      id: "string (auto-generated)",
+      description: "string \u2014 task description",
+      status: "pending | in_progress | completed"
+    },
+    defaultStatus: "pending"
+  },
+  review_findings: {
+    description: "Code review findings from the code_reviewer sub-agent",
+    fields: {
+      id: "string (auto-generated)",
+      description: "string \u2014 finding description",
+      status: "open | resolved | dismissed",
+      severity: "minor | major | critical (optional)"
+    },
+    defaultStatus: "open"
+  }
+};
+function computeSettlement(session, pendingQuestionsCount, pendingConfirmationsCount, activeExecutionStatus, completedEvidence = false) {
+  if (session.phase === "done") return { settled: true, outcome: "completed" };
+  if (session.phase === "blocked") return { settled: true, outcome: "blocked" };
+  const waitingForUser = pendingQuestionsCount > 0 || pendingConfirmationsCount > 0 || activeExecutionStatus === "waiting";
+  if (waitingForUser) return { settled: true, outcome: "waiting" };
+  if (completedEvidence && !session.isRunning) return { settled: true, outcome: "completed" };
+  return { settled: false, outcome: null };
+}
+function workflowPayload(execution) {
+  if (!execution) return null;
+  const pausedAtUserStep = execution.status === "waiting" && (execution.pendingChoices?.length ?? 0) > 0;
+  return {
+    id: execution.id,
+    name: execution.workflowName,
+    status: execution.status,
+    ...execution.currentStepId ? { currentStepId: execution.currentStepId } : {},
+    ...execution.currentStepName ? { currentStepName: execution.currentStepName } : {},
+    stepOutput: execution.stepOutput,
+    ...execution.pendingChoices ? { pendingChoices: execution.pendingChoices } : {},
+    ...execution.subGroup ? { subGroup: execution.subGroup } : {},
+    ...pausedAtUserStep ? { resumeHint: "Call openfox_resume_workflow with choice set to one of the pendingChoices ids above." } : {}
+  };
+}
+function normalizeMetadataId(id) {
+  if (typeof id !== "string" && typeof id !== "number") return void 0;
+  if (id === "") return void 0;
+  return String(id);
+}
+function resolveWaitTimeout(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return WAIT_TIMEOUT_SECONDS_DEFAULT;
+  return Math.max(WAIT_TIMEOUT_SECONDS_MIN, Math.min(WAIT_TIMEOUT_SECONDS_MAX, Math.floor(value)));
+}
+var sleep2 = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
+function ok(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload) }] };
+}
+function fail(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+function truncate(content, maxLength) {
+  return content.length > maxLength ? `${content.slice(0, maxLength)}...` : content;
+}
+function resolveMaxContentLength(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return MAX_DETAIL_CONTENT_LENGTH_DEFAULT;
+  return Math.max(MIN_DETAIL_CONTENT_LENGTH, Math.min(MAX_DETAIL_CONTENT_LENGTH_HARD_CAP, Math.floor(value)));
+}
+function buildSessionStatusPayload(sessionId, deps) {
+  const session = deps.sessionManager.getSession(sessionId);
+  if (!session) return null;
+  const pendingQuestions = deps.pendingQuestions(sessionId);
+  const pendingConfirmations = deps.pendingConfirmations(sessionId);
+  const activeExecution = deps.sessionManager.getActiveWorkflowExecution(sessionId);
+  const status = projectSessionStatus({
+    session,
+    pendingQuestionsCount: pendingQuestions.length,
+    pendingConfirmationsCount: pendingConfirmations.length,
+    activeWorkflowStepName: activeExecution?.currentStepName ?? null
+  });
+  return {
+    ...status,
+    isRunning: session.isRunning,
+    pending: { questions: pendingQuestions, confirmations: pendingConfirmations },
+    workflow: workflowPayload(activeExecution)
+  };
+}
+function createOpenFoxMcpTools(deps) {
+  const { sessionManager } = deps;
+  const requireSession = (sessionId) => {
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      return { ok: false, error: "sessionId is required" };
+    }
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      return { ok: false, error: `Session not found: ${sessionId}` };
+    }
+    return { ok: true, session };
+  };
+  const requireSessionAndId = (args) => {
+    const check = requireSession(args["sessionId"]);
+    if (!check.ok) return check;
+    return { ok: true, session: check.session, sessionId: check.session.id };
+  };
+  const resolvePendingCallId = (sessionId, callId, pending, noun) => {
+    if (typeof callId !== "string" || callId.length === 0) {
+      return { kind: "list" };
+    }
+    if (!pending.some((item) => item.callId === callId)) {
+      return { kind: "error", error: `No pending ${noun} with callId "${callId}" for session ${sessionId}` };
+    }
+    return { kind: "found", callId };
+  };
+  const tools = [
+    {
+      name: "openfox_projects",
+      description: "List all OpenFox projects.",
+      inputSchema: {},
+      handler: async () => {
+        const projects = deps.listProjects();
+        return ok(projects);
+      }
+    },
+    {
+      name: "openfox_create_project",
+      description: "Create a new OpenFox project at the given directory. Creates the directory and initializes git if missing, then registers the project.",
+      inputSchema: {
+        name: z.string().describe("Project name (letters, numbers, hyphens, underscores, dots, spaces)"),
+        workdir: z.string().describe("Absolute path of the project directory")
+      },
+      handler: async (args) => {
+        const name = args["name"];
+        const workdir = args["workdir"];
+        if (typeof name !== "string" || name.trim().length === 0) {
+          return fail("name is required");
+        }
+        if (typeof workdir !== "string" || workdir.trim().length === 0) {
+          return fail("workdir is required");
+        }
+        try {
+          const project = await deps.createProject(name.trim(), workdir.trim());
+          return ok({ project });
+        } catch (error) {
+          return fail(error instanceof Error ? error.message : String(error));
+        }
+      }
+    },
+    {
+      name: "openfox_delete_project",
+      description: "Delete an OpenFox project and all its sessions by id.",
+      inputSchema: {
+        projectId: z.string().describe("Project id to delete")
+      },
+      handler: async (args) => {
+        const projectId = args["projectId"];
+        if (typeof projectId !== "string" || projectId.length === 0) {
+          return fail("projectId is required");
+        }
+        const deleted = deps.deleteProject(projectId);
+        return ok({ deleted });
+      }
+    },
+    {
+      name: "openfox_create_session",
+      description: "Create a new OpenFox session in a project, optionally selecting an agent (e.g. planner or builder) as the session mode.",
+      inputSchema: {
+        projectId: z.string().describe("Project to create the session in"),
+        title: z.string().optional().describe("Optional session title"),
+        agentId: z.string().optional().describe("Optional agent to use as the session mode (validated against available top-level agents)")
+      },
+      handler: async (args) => {
+        const projectId = args["projectId"];
+        if (typeof projectId !== "string" || projectId.length === 0) {
+          return fail("projectId is required");
+        }
+        const title = typeof args["title"] === "string" ? args["title"] : void 0;
+        const rawAgentId = args["agentId"];
+        const agentId = typeof rawAgentId === "string" && rawAgentId.trim().length > 0 ? rawAgentId : void 0;
+        try {
+          const session = sessionManager.createSession(projectId, title, null, null);
+          if (agentId) {
+            const project = sessionManager.getProject(projectId);
+            const topLevelIds = project ? await deps.topLevelAgentIds(project.workdir) : [];
+            if (!topLevelIds.includes(agentId)) {
+              return fail(
+                `Invalid agentId "${agentId}". Must be one of: ${topLevelIds.join(", ") || "(none available)"}`
+              );
+            }
+            sessionManager.setMode(session.id, agentId);
+          }
+          return ok({
+            sessionId: session.id,
+            projectId,
+            title: session.metadata?.title ?? title ?? null,
+            mode: agentId ?? session.mode
+          });
+        } catch (error) {
+          return fail(error instanceof Error ? error.message : String(error));
+        }
+      }
+    },
+    {
+      name: "openfox_set_mode",
+      description: "Switch an existing session to a different mode (agent, e.g. planner or builder) at any time. The mode is validated against the session project\u2019s top-level agents.",
+      inputSchema: {
+        sessionId: z.string().describe("Session to switch"),
+        mode: z.string().describe("Target mode: one of the session project\u2019s top-level agents")
+      },
+      handler: async (args) => {
+        const check = requireSession(args["sessionId"]);
+        if (!check.ok) return fail(check.error);
+        const session = check.session;
+        const mode = args["mode"];
+        if (typeof mode !== "string" || mode.trim().length === 0) {
+          return fail("mode is required");
+        }
+        const project = sessionManager.getProject(session.projectId);
+        const topLevelIds = project ? await deps.topLevelAgentIds(project.workdir) : [];
+        if (!topLevelIds.includes(mode)) {
+          return fail(`Invalid mode "${mode}". Must be one of: ${topLevelIds.join(", ") || "(none available)"}`);
+        }
+        const updated = sessionManager.setMode(session.id, mode);
+        return ok({ sessionId: session.id, mode: updated?.mode ?? mode });
+      }
+    },
+    {
+      name: "openfox_sessions",
+      description: "List sessions, optionally scoped to a project, with running state and pending interaction counts.",
+      inputSchema: {
+        projectId: z.string().optional().describe("Scope the listing to a project"),
+        limit: z.number().int().positive().optional().describe("Maximum sessions to return (default 20)"),
+        offset: z.number().int().nonnegative().optional().describe("Number of sessions to skip (default 0)")
+      },
+      handler: async (args) => {
+        const limit = typeof args["limit"] === "number" ? args["limit"] : 20;
+        const offset = typeof args["offset"] === "number" ? args["offset"] : 0;
+        const projectId = args["projectId"];
+        const result = typeof projectId === "string" && projectId.length > 0 ? sessionManager.listSessionsByProject(projectId, limit, offset) : sessionManager.listSessionsLimited(limit, offset);
+        const sessions = result.sessions.map((s) => ({
+          id: s.id,
+          projectId: s.projectId,
+          title: s.title ?? null,
+          isRunning: s.isRunning,
+          pendingQuestionCount: deps.pendingQuestions(s.id).length,
+          pendingConfirmationCount: deps.pendingConfirmations(s.id).length,
+          pausedWorkflowStep: sessionManager.getActiveWorkflowExecution(s.id)?.status === "waiting",
+          updatedAt: s.updatedAt
+        }));
+        return ok({ sessions, hasMore: result.hasMore });
+      }
+    },
+    {
+      name: "openfox_session_status",
+      description: "Read a session state snapshot: projected status, running flag, active workflow execution (including a paused user step with its choices), pending questions and confirmations, last activity, and a UI link.",
+      inputSchema: {
+        sessionId: z.string().describe("Session to inspect")
+      },
+      handler: async (args) => {
+        const check = requireSession(args["sessionId"]);
+        if (!check.ok) return fail(check.error);
+        const payload = buildSessionStatusPayload(check.session.id, deps);
+        if (!payload) return fail(`Session not found: ${check.session.id}`);
+        return ok(payload);
+      }
+    },
+    {
+      name: "openfox_session_detail",
+      description: "Read the most recent messages of a session (content truncated) so progress can be followed without a live WebSocket.",
+      inputSchema: {
+        sessionId: z.string().describe("Session to read"),
+        limit: z.number().int().positive().optional().describe("Maximum messages to return (default 20, capped at 50)"),
+        maxContentLength: z.number().int().positive().optional().describe("Maximum content length per message (default 400, clamped to 50\u201310000)")
+      },
+      handler: async (args) => {
+        const check = requireSession(args["sessionId"]);
+        if (!check.ok) return fail(check.error);
+        const limit = typeof args["limit"] === "number" ? args["limit"] : 20;
+        const maxContentLength = resolveMaxContentLength(args["maxContentLength"]);
+        const { messages, hiddenCount } = deps.recentMessages(check.session.id, limit);
+        return ok({
+          messages: messages.map((message) => ({
+            id: message.id,
+            role: message.role,
+            content: truncate(message.content ?? "", maxContentLength),
+            ...message.toolCalls && message.toolCalls.length > 0 ? { toolCalls: message.toolCalls.map((toolCall) => toolCall.name) } : {}
+          })),
+          hiddenCount
+        });
+      }
+    },
+    {
+      name: "openfox_session_metadata",
+      description: "Manage structured session data by key (criteria, todos, review_findings, ...). Actions: get (list entries for a key), list (keys), add, update, remove, schema. Writes land in the same store as the agent\u2019s session_metadata tool, so they drive workflow transitions.",
+      inputSchema: {
+        sessionId: z.string().describe("Session to manage"),
+        action: z.enum(["get", "list", "add", "update", "remove", "schema"]).describe("Operation to perform"),
+        key: z.string().optional().describe("Metadata key (required for get/add/update/remove/schema)"),
+        id: z.string().optional().describe("Item id (required for update and remove)"),
+        description: z.string().optional().describe("Item description (required for add)"),
+        status: z.string().optional().describe("Item status (for add/update)")
+      },
+      handler: async (args) => {
+        const check = requireSession(args["sessionId"]);
+        if (!check.ok) return fail(check.error);
+        const session = check.session;
+        const action = args["action"];
+        const key = typeof args["key"] === "string" && args["key"].length > 0 ? args["key"] : void 0;
+        const entries = session.metadataEntries ?? {};
+        if (action === "list") {
+          return ok({ keys: Object.entries(entries).map(([k, v]) => ({ key: k, count: v.length })) });
+        }
+        if (action === "schema") {
+          if (!key) return fail("key is required for schema");
+          const schema = METADATA_SCHEMAS[key];
+          if (!schema) return ok({ key, generic: true });
+          return ok({ key, description: schema.description, fields: schema.fields });
+        }
+        if (action === "get") {
+          if (!key) return fail("key is required for get");
+          return ok({ key, entries: entries[key] ?? [] });
+        }
+        if (action === "add") {
+          if (!key) return fail("key is required for add");
+          const description = args["description"];
+          if (typeof description !== "string" || description.trim().length === 0) {
+            return fail("description is required for add");
+          }
+          const current = entries[key] ?? [];
+          const newEntry = {
+            id: normalizeMetadataId(args["id"]) ?? (current.length + 1).toString(),
+            description,
+            status: typeof args["status"] === "string" ? args["status"] : METADATA_SCHEMAS[key]?.defaultStatus ?? "pending"
+          };
+          const updated = [...current, newEntry];
+          deps.setMetadataEntries(session.id, key, updated);
+          return ok({ key, added: newEntry, entries: updated });
+        }
+        if (action === "update") {
+          if (!key) return fail("key is required for update");
+          const id = normalizeMetadataId(args["id"]);
+          if (!id) return fail("id is required for update");
+          const current = entries[key];
+          if (!current) return fail(`Key "${key}" not found`);
+          const idx = current.findIndex((e) => e.id === id);
+          if (idx === -1) return fail(`Item "${id}" not found in "${key}"`);
+          const description = args["description"];
+          const status = args["status"];
+          if (typeof description !== "string" && typeof status !== "string") {
+            return fail("provide at least one of description or status for update");
+          }
+          const updated = current.map(
+            (e, i) => i === idx ? {
+              ...e,
+              ...typeof description === "string" ? { description } : {},
+              ...typeof status === "string" ? { status } : {}
+            } : e
+          );
+          deps.setMetadataEntries(session.id, key, updated);
+          return ok({ key, updated: id, entries: updated });
+        }
+        if (action === "remove") {
+          if (!key) return fail("key is required for remove");
+          const id = normalizeMetadataId(args["id"]);
+          if (!id) return fail("id is required for remove");
+          const current = entries[key];
+          if (!current) return fail(`Key "${key}" not found`);
+          const updated = current.filter((e) => e.id !== id);
+          if (updated.length === current.length) return fail(`Item "${id}" not found in "${key}"`);
+          deps.setMetadataEntries(session.id, key, updated);
+          return ok({ key, removed: id, entries: updated });
+        }
+        return fail(`Unknown action "${String(action)}". Must be one of: get, list, add, update, remove, schema`);
+      }
+    },
+    {
+      name: "openfox_send_message",
+      description: "Queue a message for a session. Safe on running sessions (queued, processed at the next turn boundary) and starts a new turn on idle sessions. Returns the queue state.",
+      inputSchema: {
+        sessionId: z.string().describe("Session to message"),
+        content: z.string().optional().describe("Message content"),
+        attachments: z.array(z.record(z.string(), z.unknown())).optional().describe("Optional attachments"),
+        messageKind: z.string().optional().describe("Optional message kind tag")
+      },
+      handler: async (args) => {
+        const check = requireSession(args["sessionId"]);
+        if (!check.ok) return fail(check.error);
+        const content = typeof args["content"] === "string" ? args["content"] : void 0;
+        const rawAttachments = args["attachments"];
+        const attachments = Array.isArray(rawAttachments) ? rawAttachments : void 0;
+        const messageKind = typeof args["messageKind"] === "string" ? args["messageKind"] : void 0;
+        if (!content?.trim() && !(attachments && attachments.length > 0)) {
+          return fail("content or attachments is required");
+        }
+        sessionManager.queueMessage(check.session.id, "asap", content, attachments, messageKind);
+        return ok({ queued: true, queueState: sessionManager.getQueueState(check.session.id) });
+      }
+    },
+    {
+      name: "openfox_continue",
+      description: "Continue an idle or blocked session: a blocked session is reset to the build phase and an auto-prompt is queued; an idle session is acknowledged (use openfox_send_message to drive it with content).",
+      inputSchema: {
+        sessionId: z.string().describe("Session to continue")
+      },
+      handler: async (args) => {
+        const check = requireSessionAndId(args);
+        if (!check.ok) return fail(check.error);
+        const { session, sessionId } = check;
+        if (session.isRunning) {
+          return fail(`Session ${sessionId} is already running`);
+        }
+        if (session.phase === "blocked") {
+          sessionManager.setPhase(sessionId, "build");
+          sessionManager.queueMessage(sessionId, "asap", CONTINUE_PROMPT, void 0, "auto-prompt");
+          return ok({ accepted: true });
+        }
+        return ok({
+          accepted: true,
+          note: `Session ${sessionId} is idle \u2014 use openfox_send_message to give it work.`
+        });
+      }
+    },
+    {
+      name: "openfox_wait",
+      description: "Block until a session settles: it finishes (completed), blocks (blocked), or pauses for the user (waiting \u2014 a pending question, path confirmation, or a paused workflow user step). Returns the outcome and a full status snapshot, or times out.",
+      inputSchema: {
+        sessionId: z.string().describe("Session to wait on"),
+        timeout: z.number().int().positive().optional().describe("Maximum wait in seconds (default 60, clamped 5\u2013600)")
+      },
+      handler: async (args) => {
+        const check = requireSession(args["sessionId"]);
+        if (!check.ok) return fail(check.error);
+        const sessionId = check.session.id;
+        const timeoutSeconds = resolveWaitTimeout(args["timeout"]);
+        const startedAt = Date.now();
+        const deadline = startedAt + timeoutSeconds * 1e3;
+        const graceUntil = startedAt + WAIT_IDLE_GRACE_MS;
+        let sawRunning = false;
+        while (true) {
+          const session = sessionManager.getSession(sessionId);
+          if (!session) return fail(`Session not found: ${sessionId}`);
+          if (session.isRunning) sawRunning = true;
+          const pendingQuestions = deps.pendingQuestions(sessionId);
+          const pendingConfirmations = deps.pendingConfirmations(sessionId);
+          const activeExecution = sessionManager.getActiveWorkflowExecution(sessionId);
+          const now = Date.now();
+          const hasWork = (session.messages?.length ?? 0) > 0;
+          const completedEvidence = sawRunning || hasWork && now >= graceUntil;
+          const settlement = computeSettlement(
+            session,
+            pendingQuestions.length,
+            pendingConfirmations.length,
+            activeExecution?.status ?? null,
+            completedEvidence
+          );
+          if (settlement.settled) {
+            return ok({
+              settled: true,
+              outcome: settlement.outcome,
+              waitedMs: now - startedAt,
+              status: buildSessionStatusPayload(sessionId, deps)
+            });
+          }
+          if (now >= deadline) {
+            return ok({
+              settled: false,
+              timedOut: true,
+              waitedMs: now - startedAt,
+              status: buildSessionStatusPayload(sessionId, deps)
+            });
+          }
+          await sleep2(WAIT_POLL_INTERVAL_MS);
+        }
+      }
+    },
+    {
+      name: "openfox_stop",
+      description: "Stop a session completely: drains the queue, aborts the active execution, and cancels pending interactions.",
+      inputSchema: {
+        sessionId: z.string().describe("Session to stop")
+      },
+      handler: async (args) => {
+        const check = requireSession(args["sessionId"]);
+        if (!check.ok) return fail(check.error);
+        deps.stopSession(check.session.id);
+        return ok({ stopped: true });
+      }
+    },
+    {
+      name: "openfox_workflows",
+      description: "List the workflows available to a project (builtin, user, and project scope) with their parameters.",
+      inputSchema: {
+        projectDir: z.string().optional().describe("Project directory for project-scoped workflows")
+      },
+      handler: async (args) => {
+        const projectDir = typeof args["projectDir"] === "string" ? args["projectDir"] : void 0;
+        return ok(await deps.listWorkflows(projectDir));
+      }
+    },
+    {
+      name: "openfox_launch_workflow",
+      description: "Launch (or resume) a workflow run in a session. On idle sessions the run starts immediately; on running sessions it is queued as a workflow-launch marker. Supports resuming paused user steps via resumeFrom/userChoice.",
+      inputSchema: {
+        sessionId: z.string().describe("Session to run the workflow in"),
+        workflowId: z.string().optional().describe("Workflow to run (default: the active workflow)"),
+        params: z.record(z.string(), z.string()).optional().describe("Workflow parameters"),
+        subGroup: z.string().optional().describe("Run only a sub-group slice of the workflow"),
+        scope: z.enum(["builtin", "user", "project"]).optional().describe("Workflow scope to resolve from"),
+        resumeFrom: z.string().optional().describe("Step id to resume a paused workflow from"),
+        stepOutput: z.record(z.string(), z.string()).optional().describe("Step output supplied when resuming"),
+        userChoice: z.string().optional().describe("Branch chosen by the user at a paused user step"),
+        content: z.string().optional().describe("Optional extra instruction for the run")
+      },
+      handler: async (args) => {
+        const check = requireSessionAndId(args);
+        if (!check.ok) return fail(check.error);
+        const { session, sessionId } = check;
+        const payload = {
+          ...typeof args["workflowId"] === "string" ? { workflowId: args["workflowId"] } : {},
+          ...args["params"] && typeof args["params"] === "object" ? { params: args["params"] } : {},
+          ...typeof args["subGroup"] === "string" ? { subGroup: args["subGroup"] } : {},
+          ...typeof args["scope"] === "string" ? { scope: args["scope"] } : {},
+          ...typeof args["resumeFrom"] === "string" ? { resumeFrom: args["resumeFrom"] } : {},
+          ...args["stepOutput"] && typeof args["stepOutput"] === "object" ? { stepOutput: args["stepOutput"] } : {},
+          ...typeof args["userChoice"] === "string" ? { userChoice: args["userChoice"] } : {},
+          ...typeof args["content"] === "string" ? { content: args["content"] } : {}
+        };
+        if (payload.workflowId && !payload.resumeFrom) {
+          const workflows = await deps.listWorkflows(session.workdir);
+          const known = workflows.some((w) => w.id === payload.workflowId);
+          if (!known) {
+            return fail(`Workflow "${payload.workflowId}" not found for project ${session.workdir}`);
+          }
+        }
+        if (session.isRunning) {
+          let fullContent = payload.content ?? "";
+          if (payload.workflowId) {
+            const workflowInfo = `// Workflow: ${payload.workflowId}`;
+            fullContent = fullContent ? `${workflowInfo}
+
+${fullContent}` : workflowInfo;
+          }
+          if (!fullContent) {
+            return fail("Session is running \u2014 give a workflowId or content to queue for the next turn boundary.");
+          }
+          sessionManager.queueMessage(sessionId, "asap", fullContent, void 0, "workflow-launch");
+          return ok({ queued: true, queueState: sessionManager.getQueueState(sessionId) });
+        }
+        if (session.phase === "blocked") {
+          sessionManager.setPhase(sessionId, "build");
+        }
+        deps.launchWorkflow(sessionId, payload);
+        return ok({ launched: true });
+      }
+    },
+    {
+      name: "openfox_resume_workflow",
+      description: 'Resolve a paused workflow user step by picking one of its choices (e.g. "Work in current workspace"). The session must be paused at a user step \u2014 see openfox_session_status \u2192 workflow.pendingChoices (and the resumeHint there). Accepts the choice id or its label.',
+      inputSchema: {
+        sessionId: z.string().describe("Session paused at a workflow user step"),
+        choice: z.string().describe("One of the pendingChoices surfaced by openfox_session_status (id or label)")
+      },
+      handler: async (args) => {
+        const check = requireSession(args["sessionId"]);
+        if (!check.ok) return fail(check.error);
+        const sessionId = check.session.id;
+        const choice = args["choice"];
+        if (typeof choice !== "string" || choice.trim().length === 0) {
+          return fail("choice is required \u2014 pick one of the pendingChoices surfaced by openfox_session_status");
+        }
+        const execution = sessionManager.getActiveWorkflowExecution(sessionId);
+        if (!execution || execution.status !== "waiting" || !execution.currentStepId) {
+          return fail(`Session ${sessionId} is not paused at a workflow user step`);
+        }
+        const pendingChoices = execution.pendingChoices ?? [];
+        if (pendingChoices.length === 0) {
+          return fail(`No choices available for paused step "${execution.currentStepName ?? execution.currentStepId}"`);
+        }
+        const match = pendingChoices.find((c) => c.id === choice || c.label === choice);
+        if (!match) {
+          return fail(`Invalid choice "${choice}". Available: ${pendingChoices.map((c) => c.id).join(", ")}`);
+        }
+        deps.launchWorkflow(sessionId, {
+          workflowId: execution.workflowId,
+          resumeFrom: execution.currentStepId,
+          userChoice: match.id,
+          stepOutput: execution.stepOutput
+        });
+        return ok({
+          resumed: true,
+          choice: match.id,
+          step: execution.currentStepName ?? execution.currentStepId
+        });
+      }
+    },
+    {
+      name: "openfox_stop_workflow",
+      description: "Abort the active workflow run of a session (task/MCP-launched runs): aborts a live run or cancels a paused user-step execution, and errors when nothing is active. Does not stop plain chat turns.",
+      inputSchema: {
+        sessionId: z.string().describe("Session whose workflow run should be aborted")
+      },
+      handler: async (args) => {
+        const check = requireSession(args["sessionId"]);
+        if (!check.ok) return fail(check.error);
+        const stopped = deps.stopWorkflow(check.session.id);
+        if (!stopped) return fail("No active workflow run to stop");
+        return ok({ stopped: true, aborted: stopped.aborted });
+      }
+    },
+    {
+      name: "openfox_answer",
+      description: "Answer or skip a pending ask_user question of a session by callId. Without a callId, lists the session pending questions.",
+      inputSchema: {
+        sessionId: z.string().describe("Session the question belongs to"),
+        callId: z.string().optional().describe("Pending question to answer (omit to list)"),
+        answer: z.string().optional().describe("The answer to provide"),
+        skip: z.boolean().optional().describe("Skip the question instead of answering it")
+      },
+      handler: async (args) => {
+        const check = requireSession(args["sessionId"]);
+        if (!check.ok) return fail(check.error);
+        const session = check.session;
+        const pending = deps.pendingQuestions(session.id);
+        const resolved = resolvePendingCallId(session.id, args["callId"], pending, "question");
+        if (resolved.kind === "list") return ok({ questions: pending });
+        if (resolved.kind === "error") return fail(resolved.error);
+        const callId = resolved.callId;
+        const skip = args["skip"] === true;
+        const answer = typeof args["answer"] === "string" ? args["answer"] : "";
+        if (!skip && answer.length === 0) {
+          return fail("answer is required unless skip is true");
+        }
+        const found = deps.answerQuestion(callId, skip ? "" : answer, skip || void 0);
+        if (!found) {
+          return fail(`Question ${callId} is no longer pending`);
+        }
+        return ok({ answered: true, callId, skipped: skip || void 0 });
+      }
+    },
+    {
+      name: "openfox_confirm",
+      description: "Resolve a pending path confirmation of a session (approve/deny, optionally always-allow the paths). Without a callId, lists the session pending confirmations.",
+      inputSchema: {
+        sessionId: z.string().describe("Session the confirmation belongs to"),
+        callId: z.string().optional().describe("Pending confirmation to resolve (omit to list)"),
+        approved: z.boolean().optional().describe("Approve or deny the requested access"),
+        alwaysAllow: z.boolean().optional().describe("Permanently allow the paths for this session")
+      },
+      handler: async (args) => {
+        const check = requireSession(args["sessionId"]);
+        if (!check.ok) return fail(check.error);
+        const session = check.session;
+        const pending = deps.pendingConfirmations(session.id);
+        const resolved = resolvePendingCallId(session.id, args["callId"], pending, "confirmation");
+        if (resolved.kind === "list") return ok({ confirmations: pending });
+        if (resolved.kind === "error") return fail(resolved.error);
+        const callId = resolved.callId;
+        const approved = args["approved"];
+        if (typeof approved !== "boolean") {
+          return fail("approved (boolean) is required");
+        }
+        const alwaysAllow = args["alwaysAllow"];
+        const found = deps.confirmPath(callId, approved, alwaysAllow);
+        if (!found) {
+          return fail(`Confirmation ${callId} is no longer pending`);
+        }
+        return ok({ confirmed: true, callId, approved });
+      }
+    }
+  ];
+  return tools;
+}
+
+// src/server/mcp/server/endpoint.ts
+function buildOpenFoxMcpServer(deps) {
+  const server = new McpServer({
+    name: "openfox",
+    version: "1.0.0"
+  });
+  for (const tool of createOpenFoxMcpTools(deps)) {
+    const config3 = { description: tool.description };
+    if (Object.keys(tool.inputSchema).length > 0) {
+      config3["inputSchema"] = tool.inputSchema;
+    }
+    server.registerTool(
+      tool.name,
+      config3,
+      async (args) => tool.handler(args ?? {})
+    );
+  }
+  return server;
+}
+function createOpenFoxMcpRouter(options) {
   const router = Router4();
+  router.all("/", async (req, res) => {
+    try {
+      if (options.isAuthRequired() && !await options.isAuthorized(req)) {
+        res.status(401).json({ error: "Unauthorized" });
+        return;
+      }
+      const deps = options.resolveDeps();
+      if (!deps) {
+        res.status(503).json({ error: "MCP server is not ready" });
+        return;
+      }
+      const server = buildOpenFoxMcpServer(deps);
+      const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+      await server.connect(transport);
+      await transport.handleRequest(req, res, req.body);
+    } catch (error) {
+      logger.error("MCP endpoint request failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      if (!res.headersSent) {
+        res.status(500).json({ error: "MCP request failed" });
+      }
+    }
+  });
+  return router;
+}
+function extractSessionToken(req) {
+  const header = req.headers["x-session-token"];
+  if (typeof header === "string" && header.length > 0) {
+    return header;
+  }
+  const authorization = req.headers["authorization"];
+  if (typeof authorization === "string" && authorization.startsWith("Bearer ")) {
+    const token = authorization.slice("Bearer ".length).trim();
+    return token.length > 0 ? token : null;
+  }
+  return null;
+}
+
+// src/server/routes/dev-server.ts
+import { Router as Router5 } from "express";
+function createDevServerRoutes() {
+  const router = Router5();
   router.get("/", async (req, res) => {
     const workdir = req.query["workdir"];
     if (!workdir) return res.status(400).json({ error: "workdir required" });
@@ -4849,7 +5681,7 @@ function createDevServerRoutes() {
 }
 
 // src/server/routes/workspace-config.ts
-import { Router as Router5 } from "express";
+import { Router as Router6 } from "express";
 import { stat as stat2, mkdir as mkdir3, readdir, access as access3 } from "fs/promises";
 import { constants as constants3 } from "fs";
 import { resolve as resolve4, isAbsolute as isAbsolute3, join as join5, win32 } from "path";
@@ -4946,7 +5778,7 @@ async function findOrphanedWorkspaces(dir) {
   return results;
 }
 function createWorkspaceConfigRoutes(sessionManager) {
-  const router = Router5();
+  const router = Router6();
   router.get("/config", async (req, res) => {
     const workdir = req.query["workdir"];
     if (!workdir) return res.status(400).json({ error: "workdir required" });
@@ -5080,9 +5912,9 @@ function createWorkspaceConfigRoutes(sessionManager) {
 }
 
 // src/server/routes/terminals.ts
-import { Router as Router6 } from "express";
+import { Router as Router7 } from "express";
 function createTerminalRoutes() {
-  const router = Router6();
+  const router = Router7();
   router.get("/", (req, res) => {
     const projectId = req.query["projectId"];
     const sessions = projectId ? terminalManager.getByProject(projectId) : [];
@@ -5121,11 +5953,11 @@ function createTerminalRoutes() {
 }
 
 // src/server/routes/directories.ts
-import { Router as Router7 } from "express";
+import { Router as Router8 } from "express";
 import { readdir as readdir2 } from "fs/promises";
 import { resolve as resolve5, join as join6, dirname as dirname4, basename as basename2 } from "path";
 function createDirectoryRoutes() {
-  const router = Router7();
+  const router = Router8();
   const DEFAULT_BASE_PATH = process.cwd();
   router.get("/", async (req, res) => {
     const path = req.query["path"] || DEFAULT_BASE_PATH;
@@ -5160,7 +5992,7 @@ function createDirectoryRoutes() {
 }
 
 // src/server/routes/file-search.ts
-import { Router as Router8 } from "express";
+import { Router as Router9 } from "express";
 import fg from "fast-glob";
 var IGNORED_PATTERNS = [
   "**/node_modules/**",
@@ -5173,7 +6005,7 @@ var IGNORED_PATTERNS = [
   "**/.openfox/**"
 ];
 function createFileSearchRoutes() {
-  const router = Router8();
+  const router = Router9();
   router.get("/", async (req, res) => {
     const query = req.query["q"] || "";
     const workdir = req.query["workdir"] || process.cwd();
@@ -5265,7 +6097,7 @@ function fuzzyScore(filePath, query) {
 }
 
 // src/server/routes/auto-update.ts
-import { Router as Router9 } from "express";
+import { Router as Router10 } from "express";
 import { spawn as spawn2 } from "child_process";
 var updateInProgress = false;
 var CACHE_TTL_MS = 60 * 60 * 1e3;
@@ -5362,7 +6194,7 @@ async function getLatestDevelopVersion() {
   });
 }
 function createAutoUpdateRoutes(options = {}) {
-  const router = Router9();
+  const router = Router10();
   router.get("/check", async (req, res) => {
     const isService = isRunningAsService();
     const isDev = isDevMode();
@@ -5479,9 +6311,9 @@ function createAutoUpdateRoutes(options = {}) {
 }
 
 // src/server/routes/provider-auth.ts
-import { Router as Router10 } from "express";
+import { Router as Router11 } from "express";
 function createProviderAuthRoutes(config3, providerManager, registry) {
-  const router = Router10();
+  const router = Router11();
   function resolveAuthContext(providerId, res) {
     const provider = providerManager.getProviders().find((item) => item.id === providerId);
     if (!provider) {
@@ -5710,7 +6542,7 @@ async function loadProviderPlugins(options) {
 }
 
 // src/server/routes/plugins.ts
-import { Router as Router11 } from "express";
+import { Router as Router12 } from "express";
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL2 } from "url";
 import { dirname as dirname6, resolve as resolve7, join as join8 } from "path";
 import { existsSync } from "fs";
@@ -5727,7 +6559,7 @@ async function openFolderRoute(dir, res) {
   }
 }
 function createPluginRoutes(options) {
-  const router = Router11();
+  const router = Router12();
   const { config: config3, providerAdapters, pluginDiagnostics, logger: logger2 } = options;
   let registryCache = null;
   router.get("/registry", async (_req, res) => {
@@ -5968,6 +6800,10 @@ function detectWsl() {
 
 // src/server/index.ts
 var __dirname3 = dirname7(fileURLToPath6(import.meta.url));
+async function announceContextDrift(sessionManager, sessionIds) {
+  const { injectContextDriftRemindersForSessions } = await import("./dynamic-context-Y555VDLA.js");
+  await injectContextDriftRemindersForSessions(sessionManager, sessionIds);
+}
 async function createServerHandle(config3) {
   setRuntimeConfig(config3);
   setLogLevel(config3.logging?.level ?? void 0, config3.mode);
@@ -6072,7 +6908,7 @@ async function createServerHandle(config3) {
       toolRegistry = createToolRegistry();
       logger.info("MCP tools registered", { count: mcpTools.length });
     }
-    const { signalMcpReady } = await import("./server-MUJ7EHEI.js");
+    const { signalMcpReady } = await import("./server-5TY22HDN.js");
     signalMcpReady();
   });
   const app = express();
@@ -6095,6 +6931,25 @@ async function createServerHandle(config3) {
   };
   app.use("/api", authMiddleware);
   app.use(express.json({ limit: "75mb" }));
+  let mcpToolDeps = null;
+  const mcpAuth = {
+    isAuthRequired: () => {
+      const cfg = getAuthConfig();
+      return cfg?.strategy === "network" && cfg.encryptedPassword != null;
+    },
+    isAuthorized: async (req) => {
+      const token = extractSessionToken(req);
+      return token ? isValidToken(token) : false;
+    }
+  };
+  app.use(
+    "/mcp",
+    createOpenFoxMcpRouter({
+      resolveDeps: () => mcpToolDeps,
+      isAuthRequired: mcpAuth.isAuthRequired,
+      isAuthorized: mcpAuth.isAuthorized
+    })
+  );
   app.get("/api/health", (_req, res) => {
     res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   });
@@ -6155,7 +7010,7 @@ async function createServerHandle(config3) {
     res.json({ tools });
   });
   app.get("/api/projects", async (_req, res) => {
-    const { listProjects: listProjects2 } = await import("./projects-TPSLCJP2.js");
+    const { listProjects: listProjects2 } = await import("./projects-5U37RUTL.js");
     const projects = listProjects2();
     res.json({ projects });
   });
@@ -6164,7 +7019,7 @@ async function createServerHandle(config3) {
     if (!name || !workdir) {
       return res.status(400).json({ error: "name and workdir are required" });
     }
-    const { createDirectoryWithGit } = await import("./project-creator-JF3YVQAH.js");
+    const { createDirectoryWithGit } = await import("./project-creator-6AGQTNXB.js");
     try {
       const project = await createDirectoryWithGit(name, workdir);
       res.status(201).json({ project });
@@ -6209,7 +7064,7 @@ async function createServerHandle(config3) {
     }
   });
   app.get("/api/projects/:id", async (req, res) => {
-    const { getProject: getProject2 } = await import("./projects-TPSLCJP2.js");
+    const { getProject: getProject2 } = await import("./projects-5U37RUTL.js");
     const project = getProject2(req.params.id);
     if (!project) {
       return res.status(404).json({ error: "Project not found" });
@@ -6217,7 +7072,7 @@ async function createServerHandle(config3) {
     res.json({ project });
   });
   app.get("/api/projects/:id/open-folder", async (req, res) => {
-    const { getProject: getProject2 } = await import("./projects-TPSLCJP2.js");
+    const { getProject: getProject2 } = await import("./projects-5U37RUTL.js");
     const project = getProject2(req.params.id);
     if (!project) {
       return res.status(404).json({ error: "Project not found" });
@@ -6231,7 +7086,7 @@ async function createServerHandle(config3) {
     }
   });
   app.put("/api/projects/:id", async (req, res) => {
-    const { updateProject: updateProject2 } = await import("./projects-TPSLCJP2.js");
+    const { updateProject: updateProject2 } = await import("./projects-5U37RUTL.js");
     const { name, customInstructions, dangerLevel, defaultAgent } = req.body;
     const updates = {};
     if (name !== void 0) updates.name = name;
@@ -6245,16 +7100,16 @@ async function createServerHandle(config3) {
     res.json({ project: updated });
   });
   app.delete("/api/projects/:id", async (req, res) => {
-    const { getProject: getProject2, deleteProject } = await import("./projects-TPSLCJP2.js");
+    const { getProject: getProject2, deleteProject: deleteProject2 } = await import("./projects-5U37RUTL.js");
     const project = getProject2(req.params.id);
     if (!project) {
       return res.status(404).json({ error: "Project not found" });
     }
-    deleteProject(req.params.id);
+    deleteProject2(req.params.id);
     res.json({ success: true });
   });
   app.put("/api/projects/:id/star", async (req, res) => {
-    const { toggleStar } = await import("./projects-TPSLCJP2.js");
+    const { toggleStar } = await import("./projects-5U37RUTL.js");
     const { isStarred } = req.body;
     if (typeof isStarred !== "boolean") {
       return res.status(400).json({ error: "isStarred is required and must be a boolean" });
@@ -6268,9 +7123,9 @@ async function createServerHandle(config3) {
   const sessionFavoriteRouter = express.Router();
   registerSessionFavoriteRoute(sessionFavoriteRouter, sessionManager);
   app.use("/api", sessionFavoriteRouter);
-  const { createTasksService } = await import("./service-INQWTYY2.js");
-  const { registerTaskRoutes } = await import("./tasks-SE3DOPVP.js");
-  const { setTasksService } = await import("./tools-6XUSIJN2.js");
+  const { createTasksService } = await import("./service-VPXGREXF.js");
+  const { registerTaskRoutes } = await import("./tasks-MNPXK2S5.js");
+  const { setTasksService } = await import("./tools-6BDT5YMT.js");
   const tasksService = createTasksService({
     sessionManager,
     config: config3,
@@ -6283,26 +7138,26 @@ async function createServerHandle(config3) {
   registerTaskRoutes(tasksRouter, tasksService);
   app.use("/api", tasksRouter);
   app.get("/api/projects/:id/branches", async (req, res) => {
-    const { getProject: getProject2 } = await import("./projects-TPSLCJP2.js");
+    const { getProject: getProject2 } = await import("./projects-5U37RUTL.js");
     const project = getProject2(req.params.id);
     if (!project) return res.status(404).json({ error: "Project not found" });
-    const { listBranches } = await import("./workspace-6CUE26YA.js");
+    const { listBranches } = await import("./workspace-LM646OHC.js");
     const branches = await listBranches(project.workdir);
     res.json({ branches });
   });
   app.post("/api/projects/:id/checkout", async (req, res) => {
-    const { getProject: getProject2 } = await import("./projects-TPSLCJP2.js");
+    const { getProject: getProject2 } = await import("./projects-5U37RUTL.js");
     const project = getProject2(req.params.id);
     if (!project) return res.status(404).json({ error: "Project not found" });
     const { branch } = req.body;
     if (!branch || typeof branch !== "string") return res.status(400).json({ error: "branch is required" });
-    const { checkoutBranch, isGitRepository } = await import("./workspace-6CUE26YA.js");
+    const { checkoutBranch, isGitRepository } = await import("./workspace-LM646OHC.js");
     if (!await isGitRepository(project.workdir)) {
       return res.status(400).json({ error: "Project is not a git repository" });
     }
     try {
       await checkoutBranch(project.workdir, branch);
-      const { updateSessionBranch: updateSessionBranch2 } = await import("./sessions-D7VRCHQY.js");
+      const { updateSessionBranch: updateSessionBranch2 } = await import("./sessions-NMPX5ICI.js");
       const allSessions = sessionManager.listSessions();
       for (const s of allSessions) {
         if (sessionManager.getEffectiveWorkdir(s.id) === project.workdir) {
@@ -6316,12 +7171,12 @@ async function createServerHandle(config3) {
     }
   });
   app.post("/api/projects/:id/checkout-new", async (req, res) => {
-    const { getProject: getProject2 } = await import("./projects-TPSLCJP2.js");
+    const { getProject: getProject2 } = await import("./projects-5U37RUTL.js");
     const project = getProject2(req.params.id);
     if (!project) return res.status(404).json({ error: "Project not found" });
     const { name, sourceBranch } = req.body;
     if (!name || typeof name !== "string") return res.status(400).json({ error: "name is required" });
-    const { createBranch, resolveAndValidateSourceBranch: resolveAndValidateSourceBranch2, validateRef: validateRef2, getDefaultBranch, isGitRepository } = await import("./workspace-6CUE26YA.js");
+    const { createBranch, resolveAndValidateSourceBranch: resolveAndValidateSourceBranch2, validateRef: validateRef2, getDefaultBranch, isGitRepository } = await import("./workspace-LM646OHC.js");
     if (!await isGitRepository(project.workdir)) {
       return res.status(400).json({ error: "Project is not a git repository" });
     }
@@ -6338,7 +7193,7 @@ async function createServerHandle(config3) {
         );
       }
       await createBranch(project.workdir, name, sb);
-      const { updateSessionBranch: updateSessionBranch2 } = await import("./sessions-D7VRCHQY.js");
+      const { updateSessionBranch: updateSessionBranch2 } = await import("./sessions-NMPX5ICI.js");
       const allSessions = sessionManager.listSessions();
       for (const s of allSessions) {
         if (sessionManager.getEffectiveWorkdir(s.id) === project.workdir) {
@@ -6355,7 +7210,7 @@ async function createServerHandle(config3) {
     const session = sessionManager.getSession(req.params.id);
     if (!session) return res.status(404).json({ error: "Session not found" });
     const effectiveWorkdir = sessionManager.getEffectiveWorkdir(req.params.id);
-    const { listBranches, getDefaultBranch } = await import("./workspace-6CUE26YA.js");
+    const { listBranches, getDefaultBranch } = await import("./workspace-LM646OHC.js");
     const [branches, defaultBranch] = await Promise.all([
       listBranches(effectiveWorkdir),
       getDefaultBranch(session.workdir)
@@ -6369,8 +7224,8 @@ async function createServerHandle(config3) {
     const { branch } = req.body;
     if (!branch || typeof branch !== "string") return res.status(400).json({ error: "branch is required" });
     const effectiveWorkdir = sessionManager.getEffectiveWorkdir(req.params.id);
-    const { checkoutBranch, validateRef: validateRef2 } = await import("./workspace-6CUE26YA.js");
-    const { updateSessionBranch: updateSessionBranch2 } = await import("./sessions-D7VRCHQY.js");
+    const { checkoutBranch, validateRef: validateRef2 } = await import("./workspace-LM646OHC.js");
+    const { updateSessionBranch: updateSessionBranch2 } = await import("./sessions-NMPX5ICI.js");
     try {
       await validateRef2(effectiveWorkdir, branch);
       await checkoutBranch(effectiveWorkdir, branch);
@@ -6412,16 +7267,16 @@ All file and git operations should use this branch.
     const { name, sourceBranch } = req.body;
     if (!name || typeof name !== "string") return res.status(400).json({ error: "name is required" });
     const effectiveWorkdir = sessionManager.getEffectiveWorkdir(req.params.id);
-    const { validateRef: validateRef2 } = await import("./workspace-6CUE26YA.js");
-    const { updateSessionBranch: updateSessionBranch2 } = await import("./sessions-D7VRCHQY.js");
+    const { validateRef: validateRef2 } = await import("./workspace-LM646OHC.js");
+    const { updateSessionBranch: updateSessionBranch2 } = await import("./sessions-NMPX5ICI.js");
     try {
       await validateRef2(effectiveWorkdir, name);
       if (sourceBranch) {
-        const { resolveAndValidateSourceBranch: resolveAndValidateSourceBranch2, createBranch } = await import("./workspace-6CUE26YA.js");
+        const { resolveAndValidateSourceBranch: resolveAndValidateSourceBranch2, createBranch } = await import("./workspace-LM646OHC.js");
         const sb = await resolveAndValidateSourceBranch2(effectiveWorkdir, sourceBranch, session.workdir);
         await createBranch(effectiveWorkdir, name, sb);
       } else {
-        const { createBranch, getDefaultBranch, resolveAndValidateSourceBranch: resolveAndValidateSourceBranch2 } = await import("./workspace-6CUE26YA.js");
+        const { createBranch, getDefaultBranch, resolveAndValidateSourceBranch: resolveAndValidateSourceBranch2 } = await import("./workspace-LM646OHC.js");
         const defaultBranch = await getDefaultBranch(session.workdir);
         const sb = await resolveAndValidateSourceBranch2(effectiveWorkdir, defaultBranch, session.workdir);
         await createBranch(effectiveWorkdir, name, sb);
@@ -6459,17 +7314,17 @@ All file and git operations should use this branch.
     }
   });
   app.get("/api/projects/:id/workspaces", async (req, res) => {
-    const { getProject: getProject2 } = await import("./projects-TPSLCJP2.js");
+    const { getProject: getProject2 } = await import("./projects-5U37RUTL.js");
     const project = getProject2(req.params.id);
     if (!project) return res.status(404).json({ error: "Project not found" });
-    const { listWorkspaces } = await import("./workspace-6CUE26YA.js");
+    const { listWorkspaces } = await import("./workspace-LM646OHC.js");
     const all = await listWorkspaces(project.name, project.workdir);
     const workspacesList = all.filter((ws) => ws.path !== project.workdir);
     res.json({ workspaces: workspacesList });
   });
   app.get("/api/sessions", async (req, res) => {
-    const { getRecentUserPromptsForSession } = await import("./events-GMHRX4LF.js");
-    const { getPendingConfirmationsBySession } = await import("./path-security-UDZ7UVWK.js");
+    const { getRecentUserPromptsForSession } = await import("./events-ZJPRGVL2.js");
+    const { getPendingConfirmationsBySession: getPendingConfirmationsBySession2 } = await import("./path-security-CBACXAMS.js");
     const projectId = req.query["projectId"];
     const rawLimit = req.query["limit"];
     const offset = parseInt(req.query["offset"]) || 0;
@@ -6492,7 +7347,7 @@ All file and git operations should use this branch.
       ...session,
       recentUserPrompts: getRecentUserPromptsForSession(session.id, 10)
     }));
-    const allPending = getPendingConfirmationsBySession();
+    const allPending = getPendingConfirmationsBySession2();
     const pendingConfirmationsBySession = {};
     for (const s of sessions) {
       const confs = allPending[s.id];
@@ -6524,7 +7379,7 @@ All file and git operations should use this branch.
         disabledServers = mcpManager.getAllServers().filter((s) => s.config.disabled).map((s) => s.name);
       }
       if (disabledServers.length > 0) {
-        const { setSessionDisabledServers: setSessionDisabledServers2 } = await import("./session-overrides-4WAD3X5Q.js");
+        const { setSessionDisabledServers: setSessionDisabledServers2 } = await import("./session-overrides-OECQYRDK.js");
         setSessionDisabledServers2(session.id, disabledServers);
       }
     } catch {
@@ -6561,7 +7416,7 @@ All file and git operations should use this branch.
     if (!target || typeof target !== "string") return res.status(400).json({ error: "target is required" });
     const project = sessionManager.getProject(session.projectId);
     if (!project) return res.status(404).json({ error: "Project not found" });
-    const { isGitRepository } = await import("./workspace-6CUE26YA.js");
+    const { isGitRepository } = await import("./workspace-LM646OHC.js");
     if (!await isGitRepository(project.workdir)) {
       return res.status(400).json({ error: "Project is not a git repository" });
     }
@@ -6579,7 +7434,7 @@ All file and git operations should use this branch.
     if (!target || typeof target !== "string") return res.status(400).json({ error: "target is required" });
     const project = sessionManager.getProject(session.projectId);
     if (!project) return res.status(404).json({ error: "Project not found" });
-    const { isGitRepository } = await import("./workspace-6CUE26YA.js");
+    const { isGitRepository } = await import("./workspace-LM646OHC.js");
     if (!await isGitRepository(project.workdir)) {
       return res.status(400).json({ error: "Project is not a git repository" });
     }
@@ -6597,22 +7452,22 @@ All file and git operations should use this branch.
     }
   });
   app.get("/api/sessions/:id", async (req, res) => {
-    const { getEventStore: getEventStore2, combineEventsWithSnapshot } = await import("./events-GMHRX4LF.js");
-    const { buildMessagesFromStoredEvents, foldPendingConfirmations } = await import("./folding-7K2GRPF4.js");
-    const { getPendingQuestionsForSession } = await import("./tools-6XUSIJN2.js");
-    const { getMaxVisibleItems } = await import("./settings-VOWWO4VG.js");
+    const { getEventStore: getEventStore2, combineEventsWithSnapshot: combineEventsWithSnapshot2 } = await import("./events-ZJPRGVL2.js");
+    const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2, foldPendingConfirmations } = await import("./folding-QRZOHY2I.js");
+    const { getPendingQuestionsForSession: getPendingQuestionsForSession2 } = await import("./tools-6BDT5YMT.js");
+    const { getMaxVisibleItems } = await import("./settings-MDCRNQBY.js");
     const session = sessionManager.getSession(req.params.id);
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
     const eventStore = getEventStore2();
     const { snapshot, events: eventsSinceSnapshot } = eventStore.getEventsSinceSnapshot(req.params.id);
-    const events = combineEventsWithSnapshot(req.params.id, snapshot, eventsSinceSnapshot);
+    const events = combineEventsWithSnapshot2(req.params.id, snapshot, eventsSinceSnapshot);
     const maxVisibleItems = req.query["full"] === "true" ? void 0 : getMaxVisibleItems() || void 0;
-    const { messages, hiddenCount } = buildMessagesFromStoredEvents(events, maxVisibleItems);
+    const { messages, hiddenCount } = buildMessagesFromStoredEvents2(events, maxVisibleItems);
     const contextState = sessionManager.getContextState(req.params.id);
     const queueState = sessionManager.getQueueState(req.params.id);
-    const pendingQuestions = getPendingQuestionsForSession(req.params.id);
+    const pendingQuestions = getPendingQuestionsForSession2(req.params.id);
     const pendingConfirmations = foldPendingConfirmations(events);
     const activeWorkflowExecution = sessionManager.getDisplayWorkflowExecution(req.params.id);
     res.json({
@@ -6627,10 +7482,10 @@ All file and git operations should use this branch.
     });
   });
   app.get("/api/sessions/:id/status", async (req, res) => {
-    const { projectSessionStatus } = await import("./session-status-6Q5B5PEN.js");
-    const { getPendingQuestionsForSession } = await import("./tools-6XUSIJN2.js");
-    const { getEventStore: getEventStore2, combineEventsWithSnapshot } = await import("./events-GMHRX4LF.js");
-    const { foldPendingConfirmations } = await import("./folding-7K2GRPF4.js");
+    const { projectSessionStatus: projectSessionStatus2 } = await import("./session-status-UFO5IFI7.js");
+    const { getPendingQuestionsForSession: getPendingQuestionsForSession2 } = await import("./tools-6BDT5YMT.js");
+    const { getEventStore: getEventStore2, combineEventsWithSnapshot: combineEventsWithSnapshot2 } = await import("./events-ZJPRGVL2.js");
+    const { foldPendingConfirmations } = await import("./folding-QRZOHY2I.js");
     const sessionId = req.params["id"];
     if (!sessionId) {
       return res.status(400).json({ error: "Session id is required" });
@@ -6641,12 +7496,12 @@ All file and git operations should use this branch.
     }
     const activeWorkflowExecution = sessionManager.getActiveWorkflowExecution(sessionId);
     const activeWorkflowStepName = activeWorkflowExecution?.currentStepName ?? null;
-    const pendingQuestions = getPendingQuestionsForSession(sessionId);
+    const pendingQuestions = getPendingQuestionsForSession2(sessionId);
     const eventStore = getEventStore2();
     const { snapshot, events: eventsSinceSnapshot } = eventStore.getEventsSinceSnapshot(sessionId);
-    const events = combineEventsWithSnapshot(sessionId, snapshot, eventsSinceSnapshot);
+    const events = combineEventsWithSnapshot2(sessionId, snapshot, eventsSinceSnapshot);
     const pendingConfirmations = foldPendingConfirmations(events);
-    const status = projectSessionStatus({
+    const status = projectSessionStatus2({
       session,
       pendingQuestionsCount: pendingQuestions.length,
       pendingConfirmationsCount: pendingConfirmations.length,
@@ -6660,8 +7515,8 @@ All file and git operations should use this branch.
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
-    const { stopSessionExecution } = await import("./chat-handler-TH6JBO6G.js");
-    const { cancelQuestionsForSession, cancelPathConfirmationsForSession } = await import("./tools-6XUSIJN2.js");
+    const { stopSessionExecution } = await import("./chat-handler-RAIMQU7F.js");
+    const { cancelQuestionsForSession, cancelPathConfirmationsForSession } = await import("./tools-6BDT5YMT.js");
     sessionManager.clearMessageQueue(sessionId);
     stopSessionExecution(sessionId, sessionManager);
     abortSession(sessionId);
@@ -6690,9 +7545,9 @@ All file and git operations should use this branch.
     res.json({ success: true });
   });
   app.post("/api/sessions/:id/provider", async (req, res) => {
-    const { getEventStore: getEventStore2, combineEventsWithSnapshot: combineEv } = await import("./events-GMHRX4LF.js");
-    const { buildMessagesFromStoredEvents } = await import("./folding-7K2GRPF4.js");
-    const { getMaxVisibleItems } = await import("./settings-VOWWO4VG.js");
+    const { getEventStore: getEventStore2, combineEventsWithSnapshot: combineEv } = await import("./events-ZJPRGVL2.js");
+    const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2 } = await import("./folding-QRZOHY2I.js");
+    const { getMaxVisibleItems } = await import("./settings-MDCRNQBY.js");
     const sessionId = req.params.id;
     const session = sessionManager.getSession(sessionId);
     if (!session) {
@@ -6709,19 +7564,20 @@ All file and git operations should use this branch.
     const resolvedModel = model ?? provider?.models?.[0]?.id ?? "auto";
     sessionManager.setSessionProvider(sessionId, providerId, resolvedModel, true, reasoningEffort);
     sessionManager.setSessionProviderActive(sessionId, true);
+    await announceContextDrift(sessionManager, [sessionId]);
     const contextState = sessionManager.getContextState(sessionId);
     const eventStore = getEventStore2();
     const { snapshot, events: eventsSinceSnapshot } = eventStore.getEventsSinceSnapshot(sessionId);
     const events = combineEv(sessionId, snapshot, eventsSinceSnapshot);
     const maxVisibleItems = getMaxVisibleItems();
-    const { messages, hiddenCount } = buildMessagesFromStoredEvents(events, maxVisibleItems || void 0);
+    const { messages, hiddenCount } = buildMessagesFromStoredEvents2(events, maxVisibleItems || void 0);
     const updatedSession = sessionManager.getSession(sessionId);
     res.json({ session: toClientSession(updatedSession), messages, hiddenCount, contextState });
   });
   app.delete("/api/sessions/:id/provider", async (req, res) => {
-    const { getEventStore: getEventStore2, combineEventsWithSnapshot: combineEv } = await import("./events-GMHRX4LF.js");
-    const { buildMessagesFromStoredEvents } = await import("./folding-7K2GRPF4.js");
-    const { getMaxVisibleItems } = await import("./settings-VOWWO4VG.js");
+    const { getEventStore: getEventStore2, combineEventsWithSnapshot: combineEv } = await import("./events-ZJPRGVL2.js");
+    const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2 } = await import("./folding-QRZOHY2I.js");
+    const { getMaxVisibleItems } = await import("./settings-MDCRNQBY.js");
     const sessionId = req.params.id;
     const session = sessionManager.getSession(sessionId);
     if (!session) {
@@ -6729,11 +7585,12 @@ All file and git operations should use this branch.
     }
     sessionManager.setSessionProvider(sessionId, null, null, false, null);
     sessionManager.setSessionProviderActive(sessionId, true);
+    await announceContextDrift(sessionManager, [sessionId]);
     const eventStore = getEventStore2();
     const { snapshot, events: eventsSinceSnapshot } = eventStore.getEventsSinceSnapshot(sessionId);
     const events = combineEv(sessionId, snapshot, eventsSinceSnapshot);
     const maxVisibleItems = getMaxVisibleItems();
-    const { messages, hiddenCount } = buildMessagesFromStoredEvents(events, maxVisibleItems || void 0);
+    const { messages, hiddenCount } = buildMessagesFromStoredEvents2(events, maxVisibleItems || void 0);
     const updatedSession = sessionManager.getSession(sessionId);
     res.json({ session: toClientSession(updatedSession), messages, hiddenCount });
   });
@@ -6850,9 +7707,9 @@ All file and git operations should use this branch.
     res.json({ success: true });
   });
   app.put("/api/sessions/:id/mode", async (req, res) => {
-    const { getEventStore: getEventStore2, combineEventsWithSnapshot: combineEv } = await import("./events-GMHRX4LF.js");
-    const { buildMessagesFromStoredEvents } = await import("./folding-7K2GRPF4.js");
-    const { getMaxVisibleItems } = await import("./settings-VOWWO4VG.js");
+    const { getEventStore: getEventStore2, combineEventsWithSnapshot: combineEv } = await import("./events-ZJPRGVL2.js");
+    const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2 } = await import("./folding-QRZOHY2I.js");
+    const { getMaxVisibleItems } = await import("./settings-MDCRNQBY.js");
     const sessionId = req.params.id;
     const session = sessionManager.getSession(sessionId);
     if (!session) {
@@ -6872,7 +7729,7 @@ All file and git operations should use this branch.
     const { snapshot, events: eventsSinceSnapshot } = eventStore.getEventsSinceSnapshot(sessionId);
     const events = combineEv(sessionId, snapshot, eventsSinceSnapshot);
     const maxVisibleItems = getMaxVisibleItems();
-    const { messages, hiddenCount } = buildMessagesFromStoredEvents(events, maxVisibleItems || void 0);
+    const { messages, hiddenCount } = buildMessagesFromStoredEvents2(events, maxVisibleItems || void 0);
     const updatedSession = sessionManager.getSession(sessionId);
     res.json({ session: toClientSession(updatedSession), messages, hiddenCount });
   });
@@ -6910,7 +7767,15 @@ All file and git operations should use this branch.
       return res.status(400).json({ error: "disabledServers must be an array of strings" });
     }
     setSessionDisabledServers(sessionId, disabledServers);
-    sessionManager.setDynamicContextChanged(sessionId, true);
+    const messages = session.messages ?? [];
+    if (messages.length === 0) {
+      const { applyDynamicContext } = await import("./dynamic-context-Y555VDLA.js");
+      const modelName = session.providerModel ?? providerManager.getCurrentModel();
+      await applyDynamicContext(sessionManager, sessionId, modelName);
+    } else {
+      sessionManager.setDynamicContextChanged(sessionId, true);
+    }
+    await announceContextDrift(sessionManager, [sessionId]);
     const state = sessionManager.getContextState(sessionId);
     wssExports.broadcastForSession(sessionId, createContextStateMessage(state));
     res.json({ disabledServers: getSessionDisabledServers(sessionId) });
@@ -6938,7 +7803,7 @@ All file and git operations should use this branch.
     if (alwaysAllow !== void 0 && typeof alwaysAllow !== "boolean") {
       return res.status(400).json({ error: "alwaysAllow must be a boolean if provided" });
     }
-    const { providePathConfirmation, getConfirmationSessionId } = await import("./tools-6XUSIJN2.js");
+    const { providePathConfirmation: providePathConfirmation2, getConfirmationSessionId } = await import("./tools-6BDT5YMT.js");
     const pendingSessionId = getConfirmationSessionId(callId);
     if (!pendingSessionId) {
       return res.status(404).json({ error: "No pending path confirmation with that ID" });
@@ -6946,22 +7811,22 @@ All file and git operations should use this branch.
     if (pendingSessionId !== sessionId) {
       return res.status(403).json({ error: "Confirmation does not belong to this session" });
     }
-    const result = providePathConfirmation(callId, approved, alwaysAllow);
+    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, combineEventsWithSnapshot: combineEvents } = await import("./events-GMHRX4LF.js");
-    const { buildMessagesFromStoredEvents, foldPendingConfirmations } = await import("./folding-7K2GRPF4.js");
-    const { createSessionStateMessage } = await import("./protocol-TS3GVTT3.js");
-    const { getPendingQuestionsForSession } = await import("./tools-6XUSIJN2.js");
-    const { getMaxVisibleItems } = await import("./settings-VOWWO4VG.js");
+    const { getEventStore: getEventStore2, combineEventsWithSnapshot: combineEvents } = await import("./events-ZJPRGVL2.js");
+    const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2, foldPendingConfirmations } = await import("./folding-QRZOHY2I.js");
+    const { createSessionStateMessage } = await import("./protocol-Y7MRKRUO.js");
+    const { getPendingQuestionsForSession: getPendingQuestionsForSession2 } = await import("./tools-6BDT5YMT.js");
+    const { getMaxVisibleItems } = await import("./settings-MDCRNQBY.js");
     const eventStore = getEventStore2();
     const { snapshot, events: eventsSinceSnapshot } = eventStore.getEventsSinceSnapshot(sessionId);
     const events = combineEvents(sessionId, snapshot, eventsSinceSnapshot);
     const maxVisibleItems = getMaxVisibleItems();
-    const { messages, hiddenCount } = buildMessagesFromStoredEvents(events, maxVisibleItems || void 0);
+    const { messages, hiddenCount } = buildMessagesFromStoredEvents2(events, maxVisibleItems || void 0);
     const pendingConfirmations = foldPendingConfirmations(events);
-    const pendingQuestions = getPendingQuestionsForSession(sessionId);
+    const pendingQuestions = getPendingQuestionsForSession2(sessionId);
     const session = sessionManager.getSession(sessionId);
     if (session) {
       const stateMsg = createSessionStateMessage(
@@ -6991,8 +7856,8 @@ All file and git operations should use this branch.
     if (!skip && typeof answer !== "string") {
       return res.status(400).json({ error: "answer is required when not skipping" });
     }
-    const { provideAnswer } = await import("./tools-6XUSIJN2.js");
-    const found = provideAnswer(callId, answer ?? "", skip ?? false);
+    const { provideAnswer: provideAnswer2 } = await import("./tools-6BDT5YMT.js");
+    const found = provideAnswer2(callId, answer ?? "", skip ?? false);
     if (!found) {
       return res.status(404).json({ error: "No pending question with that ID" });
     }
@@ -7024,7 +7889,7 @@ All file and git operations should use this branch.
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
-    const { getSetting: getSetting2, SETTINGS_KEYS } = await import("./settings-VOWWO4VG.js");
+    const { getSetting: getSetting2, SETTINGS_KEYS } = await import("./settings-MDCRNQBY.js");
     if (getSetting2(SETTINGS_KEYS.CACHE_WARMING) !== "true") {
       return res.json({ success: false, reason: "disabled" });
     }
@@ -7057,7 +7922,7 @@ All file and git operations should use this branch.
       backend: activeProvider?.backend ?? llmClient.getBackend(),
       model: llmClient.getModel()
     };
-    const { runAgentTurn, TurnMetrics } = await import("./orchestrator-E6GIZGEN.js");
+    const { runAgentTurn, TurnMetrics } = await import("./orchestrator-SQN2SJ2A.js");
     runAgentTurn(
       {
         sessionManager,
@@ -7095,15 +7960,15 @@ All file and git operations should use this branch.
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
-    const { stopSessionExecution } = await import("./chat-handler-TH6JBO6G.js");
-    const { cancelQuestionsForSession, cancelPathConfirmationsForSession } = await import("./tools-6XUSIJN2.js");
+    const { stopSessionExecution } = await import("./chat-handler-RAIMQU7F.js");
+    const { cancelQuestionsForSession, cancelPathConfirmationsForSession } = await import("./tools-6BDT5YMT.js");
     const queuedMessages = sessionManager.getQueueState(sessionId);
     sessionManager.clearMessageQueue(sessionId);
     stopSessionExecution(sessionId, sessionManager);
     abortSession(sessionId);
     cancelQuestionsForSession(sessionId, "Session stopped by user");
     cancelPathConfirmationsForSession(sessionId, "Session stopped by user");
-    const eventStore = (await import("./events-GMHRX4LF.js")).getEventStore();
+    const eventStore = (await import("./events-ZJPRGVL2.js")).getEventStore();
     eventStore.append(sessionId, { type: "running.changed", data: { isRunning: false } });
     res.json({ success: true, queuedMessages });
   });
@@ -7117,7 +7982,7 @@ All file and git operations should use this branch.
     if (typeof messageIndex !== "number" || messageIndex < 0) {
       return res.status(400).json({ error: "messageIndex must be a non-negative number" });
     }
-    const { truncateSessionMessages } = await import("./events-GMHRX4LF.js");
+    const { truncateSessionMessages } = await import("./events-ZJPRGVL2.js");
     truncateSessionMessages(sessionId, messageIndex);
     res.json({ success: true });
   });
@@ -7137,11 +8002,11 @@ All file and git operations should use this branch.
     if (attachments !== void 0 && !Array.isArray(attachments)) {
       return res.status(400).json({ error: "attachments must be an array if provided" });
     }
-    const { getEventStore: getEventStore2 } = await import("./events-GMHRX4LF.js");
-    const { buildMessagesFromStoredEvents } = await import("./folding-7K2GRPF4.js");
+    const { getEventStore: getEventStore2 } = await import("./events-ZJPRGVL2.js");
+    const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2 } = await import("./folding-QRZOHY2I.js");
     const eventStore = getEventStore2();
     const events = eventStore.getEvents(sessionId);
-    const { messages } = buildMessagesFromStoredEvents(events);
+    const { messages } = buildMessagesFromStoredEvents2(events);
     const msgIndex = messages.findIndex((m) => m.id === messageId);
     if (msgIndex === -1) {
       return res.status(400).json({ error: "Message not found" });
@@ -7150,7 +8015,7 @@ All file and git operations should use this branch.
     if (msg.role !== "user" || msg.isSystemGenerated) {
       return res.status(400).json({ error: "Can only replay user messages" });
     }
-    const { truncateSessionMessages } = await import("./events-GMHRX4LF.js");
+    const { truncateSessionMessages } = await import("./events-ZJPRGVL2.js");
     truncateSessionMessages(sessionId, msgIndex - 1);
     sessionManager.queueMessage(
       sessionId,
@@ -7212,7 +8077,7 @@ All file and git operations should use this branch.
     res.json({ accepted: true });
   });
   app.get("/api/settings", async (req, res) => {
-    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-VOWWO4VG.js");
+    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-MDCRNQBY.js");
     const keysParam = req.query["keys"];
     if (!keysParam) {
       return res.status(400).json({ error: "keys query parameter is required" });
@@ -7225,19 +8090,19 @@ All file and git operations should use this branch.
     res.json(result);
   });
   app.get("/api/settings/:key", async (req, res) => {
-    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-VOWWO4VG.js");
+    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-MDCRNQBY.js");
     const key = req.params.key;
     const value = getSetting2(key) ?? SETTINGS_DEFAULTS[key] ?? null;
     res.json({ key, value });
   });
   app.get("/api/settings/:key", async (req, res) => {
-    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-VOWWO4VG.js");
+    const { getSetting: getSetting2, SETTINGS_DEFAULTS } = await import("./settings-MDCRNQBY.js");
     const key = req.params.key;
     const value = getSetting2(key) ?? SETTINGS_DEFAULTS[key] ?? null;
     res.json({ key, value });
   });
   app.put("/api/settings/:key", async (req, res) => {
-    const { setSetting: setSetting2 } = await import("./settings-VOWWO4VG.js");
+    const { setSetting: setSetting2 } = await import("./settings-MDCRNQBY.js");
     const key = req.params.key;
     const { value } = req.body;
     if (value === void 0) {
@@ -7264,7 +8129,7 @@ All file and git operations should use this branch.
     }
   });
   app.get("/api/tools/shells", async (_req, res) => {
-    const { listAvailableShells } = await import("./platform-EMKWQTZX.js");
+    const { listAvailableShells } = await import("./platform-5LQXOZO3.js");
     res.json({ shells: listAvailableShells() });
   });
   app.get("/api/config", async (_req, res) => {
@@ -7338,6 +8203,7 @@ All file and git operations should use this branch.
       ...m.requestBody !== void 0 && { requestBody: m.requestBody },
       ...m.reasoningEfforts !== void 0 && { reasoningEfforts: m.reasoningEfforts },
       ...m.reasoningEffortOverride !== void 0 && { reasoningEffortOverride: m.reasoningEffortOverride },
+      ...m.modes !== void 0 && { modes: m.modes },
       ...m.supportsVision !== void 0 && { supportsVision: m.supportsVision },
       ...m.thinkingEnabled !== void 0 && { thinkingEnabled: m.thinkingEnabled },
       ...m.thinkingLevel !== void 0 && { thinkingLevel: m.thinkingLevel },
@@ -7356,7 +8222,7 @@ All file and git operations should use this branch.
     }));
   }
   app.post("/api/proxy/test", async (_req, res) => {
-    const { getSetting: getSetting2, SETTINGS_KEYS } = await import("./settings-VOWWO4VG.js");
+    const { getSetting: getSetting2, SETTINGS_KEYS } = await import("./settings-MDCRNQBY.js");
     const proxyUrl = getSetting2(SETTINGS_KEYS.PROXY_URL);
     if (!proxyUrl) {
       return res.status(400).json({ success: false, error: "No proxy URL configured" });
@@ -7387,7 +8253,7 @@ All file and git operations should use this branch.
       res.json({
         success: true,
         url,
-        backend: reqBackend || "unknown",
+        backend: reqBackend !== "unknown" && reqBackend ? reqBackend : detectBackendFromUrl(url) ?? "unknown",
         model
       });
     } catch (error) {
@@ -7448,7 +8314,7 @@ All file and git operations should use this branch.
     }
   });
   app.post("/api/proxy/test", async (_req, res) => {
-    const { getSetting: getSetting2, SETTINGS_KEYS } = await import("./settings-VOWWO4VG.js");
+    const { getSetting: getSetting2, SETTINGS_KEYS } = await import("./settings-MDCRNQBY.js");
     const proxyUrl = getSetting2(SETTINGS_KEYS.PROXY_URL);
     if (!proxyUrl) {
       return res.status(400).json({ success: false, error: "No proxy URL configured" });
@@ -7475,9 +8341,9 @@ All file and git operations should use this branch.
     const backend = req.query["backend"];
     if (!url) return res.status(400).json({ error: "url is required" });
     try {
-      const { fetchModelsWithContext } = await import("./provider-manager-PU7RS2TK.js");
-      const { getModelProfile: getModelProfile2 } = await import("./profiles-HXGJIPF2.js");
-      const { getCatalogEntry } = await import("./model-catalog-ZLOWTQA7.js");
+      const { fetchModelsWithContext } = await import("./provider-manager-URNJBK5Q.js");
+      const { getModelProfile: getModelProfile2 } = await import("./profiles-EBCVFYG7.js");
+      const { getCatalogEntry } = await import("./model-catalog-2PCKTYGW.js");
       const models = await fetchModelsWithContext(
         url,
         apiKey,
@@ -7493,6 +8359,7 @@ All file and git operations should use this branch.
           return {
             id: m.id,
             contextWindow: m.contextWindow,
+            supportsVision: m.supportsVision ?? profile.supportsVision,
             defaultTemperature: profile.temperature,
             defaultTopP: profile.topP,
             defaultTopK: profile.topK,
@@ -7514,7 +8381,7 @@ All file and git operations should use this branch.
     if (!url) return res.status(400).json({ error: "url is required" });
     if (!models?.length) return res.status(400).json({ error: "models is required" });
     try {
-      const { autoConfig } = await import("./auto-config-454YE6KC.js");
+      const { autoConfig } = await import("./auto-config-5VSNLVNI.js");
       const result = await autoConfig({
         url,
         ...apiKey ? { apiKey } : {},
@@ -7546,10 +8413,10 @@ All file and git operations should use this branch.
         });
         return res.json({ success: true, message: { content: response2.content }, raw: response2 });
       }
-      const { getModelProfile: getModelProfile2 } = await import("./profiles-HXGJIPF2.js");
-      const { getBackendCapabilities } = await import("./backend-4YPEC3J2.js");
-      const { buildNonStreamingCreateParams } = await import("./client-pure-GU2SV3DD.js");
-      const { OpenAIHttpClient } = await import("./http-client-ROVNSHF6.js");
+      const { getModelProfile: getModelProfile2 } = await import("./profiles-EBCVFYG7.js");
+      const { getBackendCapabilities } = await import("./backend-NDBY3DAQ.js");
+      const { buildNonStreamingCreateParams } = await import("./client-pure-FLKP6PTI.js");
+      const { OpenAIHttpClient } = await import("./http-client-P4XTKAZA.js");
       const { ensureVersionPrefix } = await import("./url-utils-C5BM7NF7.js");
       const profile = getModelProfile2(model);
       const capabilities = getBackendCapabilities(backend || "unknown");
@@ -7565,7 +8432,7 @@ All file and git operations should use this branch.
         modelSettings["queryParams"] = JSON.parse(rawQP);
       } else {
         const modeEnabled = mode === "thinking" ? modelConfig?.thinkingEnabled : modelConfig?.nonThinkingEnabled;
-        if (modeEnabled) {
+        if (modeEnabled && capabilities.supportsChatTemplateKwargs) {
           modelSettings["chatTemplateKwargs"] = mode === "thinking" ? { enable_thinking: true } : { enable_thinking: false };
         }
       }
@@ -7622,7 +8489,7 @@ All file and git operations should use this branch.
     try {
       const { loadGlobalConfig, saveGlobalConfig, addProvider, setDefaultModelSelection } = await import("./config-LOK3LXFH.js");
       const globalConfig = await loadGlobalConfig(config3.mode ?? "production", config3.globalConfigPath);
-      const providerBackend = backend;
+      const providerBackend = backend === "unknown" ? detectBackendFromUrl(url) ?? "unknown" : backend;
       const providerModels = modelConfigs?.length ? buildModelConfigs(modelConfigs) : model ? [{ id: model, contextWindow: 2e5, source: "user" }] : [];
       const configWithProvider = addProvider(globalConfig, {
         name,
@@ -7679,15 +8546,15 @@ All file and git operations should use this branch.
     }
   });
   app.put("/api/config/vision-fallback", async (req, res) => {
-    const { z } = await import("zod");
-    const visionFallbackUpdateSchema = z.object({
-      enabled: z.boolean().optional(),
-      url: z.string().optional(),
-      model: z.string().optional(),
-      timeout: z.number().positive().optional(),
-      backend: z.enum(["ollama", "openai"]).optional(),
-      providerModelRef: z.string().optional(),
-      apiKey: z.string().optional()
+    const { z: z2 } = await import("zod");
+    const visionFallbackUpdateSchema = z2.object({
+      enabled: z2.boolean().optional(),
+      url: z2.string().optional(),
+      model: z2.string().optional(),
+      timeout: z2.number().positive().optional(),
+      backend: z2.enum(["ollama", "openai"]).optional(),
+      providerModelRef: z2.string().optional(),
+      apiKey: z2.string().optional()
     });
     const parsed = visionFallbackUpdateSchema.safeParse(req.body);
     if (!parsed.success) {
@@ -7722,14 +8589,14 @@ All file and git operations should use this branch.
     }
   });
   app.post("/api/config/vision-fallback/test", async (req, res) => {
-    const { z } = await import("zod");
-    const testSchema = z.object({
-      url: z.string().optional(),
-      model: z.string().optional(),
-      backend: z.enum(["ollama", "openai"]).optional(),
-      providerModelRef: z.string().optional(),
-      timeout: z.number().positive().optional(),
-      apiKey: z.string().optional()
+    const { z: z2 } = await import("zod");
+    const testSchema = z2.object({
+      url: z2.string().optional(),
+      model: z2.string().optional(),
+      backend: z2.enum(["ollama", "openai"]).optional(),
+      providerModelRef: z2.string().optional(),
+      timeout: z2.number().positive().optional(),
+      apiKey: z2.string().optional()
     });
     const parsed = testSchema.safeParse(req.body);
     if (!parsed.success) {
@@ -7966,7 +8833,7 @@ All file and git operations should use this branch.
   });
   async function rebuildMcpTools() {
     const { createMcpTools: createMcpTools2 } = await import("./tool-adapter-FJAFLDZA.js");
-    const { setMcpTools: setMcpTools2 } = await import("./tools-6XUSIJN2.js");
+    const { setMcpTools: setMcpTools2 } = await import("./tools-6BDT5YMT.js");
     const mcpTools = createMcpTools2(mcpManager);
     setMcpTools2(mcpTools);
     toolRegistry = createToolRegistry();
@@ -8058,6 +8925,10 @@ All file and git operations should use this branch.
         for (const s of sessions) {
           sessionManager.setDynamicContextChanged(s.id, true);
         }
+        await announceContextDrift(
+          sessionManager,
+          sessions.map((s) => s.id)
+        );
       }
       const allServers = mcpManager.getAllServers();
       wssExports.broadcastAll(createServerMessage("mcp.servers.changed", { servers: allServers }));
@@ -8136,6 +9007,10 @@ All file and git operations should use this branch.
       for (const s of sessions) {
         sessionManager.setDynamicContextChanged(s.id, true);
       }
+      await announceContextDrift(
+        sessionManager,
+        sessions.map((s) => s.id)
+      );
       wssExports.broadcastAll(createServerMessage("mcp.servers.changed", { servers: mcpManager.getAllServers() }));
       res.json({ server: mcpManager.getServer(name) });
     } catch (error) {
@@ -8168,11 +9043,15 @@ All file and git operations should use this branch.
     for (const s of sessions) {
       sessionManager.setDynamicContextChanged(s.id, true);
     }
+    await announceContextDrift(
+      sessionManager,
+      sessions.map((s) => s.id)
+    );
     wssExports.broadcastAll(createServerMessage("mcp.servers.changed", { servers: mcpManager.getAllServers() }));
     res.json({ success: true });
   });
   function oauthCallbackPage(message) {
-    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>OpenFox</title></head><body style="font-family:system-ui;padding:2rem"><p>${message}</p></body></html>`;
+    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>OpenFox</title></head><body style="font-family:system-ui;padding:2rem"><p>${message}</p><script>try{new BroadcastChannel('openfox-oauth').postMessage({type:'oauth-callback-complete'})}catch{}</script></body></html>`;
   }
   function parseOAuthResponse(value) {
     let params;
@@ -8189,14 +9068,19 @@ All file and git operations should use this branch.
   async function applyMcpOAuthResult(name) {
     await mcpManager.connectServer(name);
     await rebuildMcpTools();
-    for (const s of sessionManager.listSessions()) {
+    const sessions = sessionManager.listSessions();
+    for (const s of sessions) {
       sessionManager.setDynamicContextChanged(s.id, true);
     }
+    await announceContextDrift(
+      sessionManager,
+      sessions.map((s) => s.id)
+    );
     wssExports.broadcastAll(createServerMessage("mcp.servers.changed", { servers: mcpManager.getAllServers() }));
   }
   async function completeMcpOAuth(name, serverUrl, code) {
     const { auth } = await import("@modelcontextprotocol/sdk/client/auth.js");
-    const { McpOAuthProvider: McpOAuthProvider2 } = await import("./oauth-provider-DGBC2YM6.js");
+    const { McpOAuthProvider: McpOAuthProvider2 } = await import("./oauth-provider-VHUS2KEG.js");
     const { clearMcpOAuthAuthorizationState } = await import("./oauth-store-KECHUT54.js");
     const provider = new McpOAuthProvider2(name, serverUrl);
     try {
@@ -8229,8 +9113,9 @@ All file and git operations should use this branch.
     }
     try {
       const { auth } = await import("@modelcontextprotocol/sdk/client/auth.js");
-      const { McpOAuthProvider: McpOAuthProvider2 } = await import("./oauth-provider-DGBC2YM6.js");
+      const { McpOAuthProvider: McpOAuthProvider2, rejectStaleOAuthClient } = await import("./oauth-provider-VHUS2KEG.js");
       const provider = new McpOAuthProvider2(name, server.config.url);
+      await rejectStaleOAuthClient(provider);
       const result = await auth(provider, { serverUrl: server.config.url });
       if (result === "AUTHORIZED") {
         await applyMcpOAuthResult(name);
@@ -8286,8 +9171,8 @@ All file and git operations should use this branch.
     if (!parsed.code || !parsed.state) {
       return res.status(400).json({ error: "Paste the whole callback URL, both code and state are needed" });
     }
-    const { readMcpOAuthEntry } = await import("./oauth-store-KECHUT54.js");
-    const entry = await readMcpOAuthEntry(name, serverUrl);
+    const { readMcpOAuthEntry: readMcpOAuthEntry2 } = await import("./oauth-store-KECHUT54.js");
+    const entry = await readMcpOAuthEntry2(name, serverUrl);
     if (!entry?.state || entry.state !== parsed.state) {
       return res.status(400).json({ error: "This callback does not match the pending authorization" });
     }
@@ -8341,13 +9226,17 @@ All file and git operations should use this branch.
       for (const s of sessions) {
         sessionManager.setDynamicContextChanged(s.id, true);
       }
+      await announceContextDrift(
+        sessionManager,
+        sessions.map((s) => s.id)
+      );
       wssExports.broadcastAll(createServerMessage("mcp.servers.changed", { servers: mcpManager.getAllServers() }));
       res.json({ success: true });
     } catch (error) {
       res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
     }
   });
-  const { listProjects } = await import("./projects-TPSLCJP2.js");
+  const { listProjects } = await import("./projects-5U37RUTL.js");
   const allProjects = listProjects();
   const projectDir = allProjects.find(
     (p) => p.workdir === config3.workdir || config3.workdir && p.workdir.startsWith(config3.workdir + "/")
@@ -8374,13 +9263,13 @@ All file and git operations should use this branch.
     })
   );
   app.get("/api/sessions/:id/background-processes", async (req, res) => {
-    const { getSessionProcesses } = await import("./manager-NOKJQTTF.js");
+    const { getSessionProcesses } = await import("./manager-TMBFBCQL.js");
     const sessionId = req.params.id;
     const processes = getSessionProcesses(sessionId);
     res.json({ processes });
   });
   app.post("/api/sessions/:id/background-process/:processId/stop", async (req, res) => {
-    const { stopProcess } = await import("./manager-NOKJQTTF.js");
+    const { stopProcess } = await import("./manager-TMBFBCQL.js");
     const sessionId = req.params.id;
     const processId = req.params.processId;
     const session = sessionManager.getSession(sessionId);
@@ -8520,7 +9409,7 @@ All file and git operations should use this branch.
   );
   const wss = wssExports.wss;
   deferTasksBroadcast = (projectId, payload) => wssExports.broadcastForProject(projectId, "", { type: "tasks.update", payload });
-  const { launchWorkflowRun, abortRunnerRun } = await import("./launch-5ARSU7EM.js");
+  const { launchWorkflowRun, abortRunnerRun } = await import("./launch-Y4H7FDU2.js");
   deferTasksLaunchWorkflow = (sessionId, launch) => {
     const effective = sessionManager.resolveEffectiveProviderModel(sessionId);
     let llmClient = getLLMClient();
@@ -8547,9 +9436,14 @@ All file and git operations should use this branch.
         broadcastForSession: wssExports.broadcastForSession
       },
       {
-        workflowId: launch.workflowId,
+        ...launch.workflowId ? { workflowId: launch.workflowId } : {},
         ...launch.params && Object.keys(launch.params).length > 0 ? { params: launch.params } : {},
+        ...launch.subGroup ? { subGroup: launch.subGroup } : {},
         ...launch.scope ? { scope: launch.scope } : {},
+        ...launch.resumeFrom ? { resumeFrom: launch.resumeFrom } : {},
+        ...launch.stepOutput ? { stepOutput: launch.stepOutput } : {},
+        ...launch.userChoice ? { userChoice: launch.userChoice } : {},
+        ...launch.content ? { content: launch.content } : {},
         ...launch.attachments && launch.attachments.length > 0 ? { attachments: launch.attachments } : {}
       }
     );
@@ -8560,7 +9454,7 @@ All file and git operations should use this branch.
     const state = sessionManager.getContextState(sessionId);
     wssExports.broadcastForSession(sessionId, createContextStateMessage(state));
   });
-  const { QueueProcessor } = await import("./processor-7RDR675X.js");
+  const { QueueProcessor } = await import("./processor-MEHODYNE.js");
   const queueProcessor = new QueueProcessor({
     sessionManager,
     providerManager,
@@ -8581,6 +9475,80 @@ All file and git operations should use this branch.
     }
     return aborted;
   };
+  mcpToolDeps = {
+    sessionManager,
+    listProjects: () => listProjects(),
+    createProject: async (name, workdir) => {
+      const { createDirectoryWithGit } = await import("./project-creator-6AGQTNXB.js");
+      return createDirectoryWithGit(name, workdir);
+    },
+    deleteProject: (projectId) => {
+      const project = getProject(projectId);
+      if (!project) return false;
+      deleteProject(projectId);
+      return true;
+    },
+    listWorkflows: (projectDir2) => listAvailableWorkflows(getGlobalConfigDir(config3.mode ?? "production"), projectDir2),
+    topLevelAgentIds: async (workdir) => {
+      const agents = await loadAllAgentsDefault(workdir);
+      return getTopLevelAgents(agents).map((a) => a.metadata.id);
+    },
+    launchWorkflow: (sessionId, launch) => deferTasksLaunchWorkflow(sessionId, launch),
+    stopSession: (sessionId) => {
+      void (async () => {
+        const { stopSessionExecution } = await import("./chat-handler-RAIMQU7F.js");
+        const { cancelQuestionsForSession, cancelPathConfirmationsForSession } = await import("./tools-6BDT5YMT.js");
+        sessionManager.clearMessageQueue(sessionId);
+        stopSessionExecution(sessionId, sessionManager);
+        abortSession(sessionId);
+        cancelQuestionsForSession(sessionId, "Session stopped by user");
+        cancelPathConfirmationsForSession(sessionId, "Session stopped by user");
+        getEventStore().append(sessionId, { type: "running.changed", data: { isRunning: false } });
+      })().catch((error) => {
+        logger.error(`MCP stopSession failed for ${sessionId}`, {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    },
+    stopWorkflow: (sessionId) => {
+      const runningAborted = abortRunnerRun(sessionId);
+      if (runningAborted) return { aborted: "running" };
+      const execution = sessionManager.getActiveWorkflowExecution(sessionId);
+      if (execution && execution.status === "waiting") {
+        sessionManager.cancelWorkflow(
+          sessionId,
+          execution.id,
+          execution.workflowId,
+          execution.workflowName,
+          execution.workflowColor
+        );
+        return { aborted: "paused" };
+      }
+      return null;
+    },
+    answerQuestion: (callId, answer, skip) => provideAnswer(callId, answer, skip),
+    pendingQuestions: (sessionId) => getPendingQuestionsForSession(sessionId),
+    confirmPath: (callId, approved, alwaysAllow) => providePathConfirmation(callId, approved, alwaysAllow).found,
+    pendingConfirmations: (sessionId) => getPendingConfirmationsBySession()[sessionId] ?? [],
+    setMetadataEntries: (sessionId, key, entries) => sessionManager.setMetadataEntries(sessionId, key, entries),
+    recentMessages: (sessionId, limit) => {
+      const eventStore = getEventStore();
+      const { snapshot, events } = eventStore.getEventsSinceSnapshot(sessionId);
+      const combined = combineEventsWithSnapshot(sessionId, snapshot, events);
+      return buildMessagesFromStoredEvents(combined, Math.max(1, Math.min(limit, 50)));
+    }
+  };
+  let mcpActualPort = null;
+  setMcpBootstrapForTools(async () => {
+    const authRequired = mcpAuth.isAuthRequired();
+    const sessionToken = authRequired ? await currentSessionToken() : null;
+    return buildOpenFoxMcpBootstrap({
+      host: config3.server.host ?? "127.0.0.1",
+      port: mcpActualPort ?? config3.server.port,
+      authRequired,
+      sessionToken
+    });
+  });
   return {
     httpServer,
     ctx: { config: config3, sessionManager, llmClient: getLLMClient(), toolRegistry, providerManager },
@@ -8591,9 +9559,13 @@ All file and git operations should use this branch.
         const addr = httpServer.address();
         const actualPort = typeof addr === "object" && addr ? addr.port : listenPort;
         setMcpOAuthServerPort(actualPort);
+        mcpActualPort = actualPort;
         const client = getLLMClient();
         logger.info(`OpenFox server running at http://${host}:${actualPort}`);
         logger.info(`WebSocket available at ws://${host}:${actualPort}/ws`);
+        logger.info(
+          `MCP endpoint available at http://${host}:${actualPort}/mcp \u2014 run 'openfox mcp' for a paste-ready client config`
+        );
         logger.info(`LLM backend: ${client.getBackend()}, model: ${client.getModel()}, url: ${config3.llm.baseUrl}`);
         resolve9({ port: actualPort });
       });
@@ -8604,7 +9576,7 @@ All file and git operations should use this branch.
       void (async () => {
         await devServerManager.stopAll();
         await mcpManager.disconnectAll();
-        const { stopAllInspectProxies } = await import("./inspect-proxy-UKPU3Z64.js");
+        const { stopAllInspectProxies } = await import("./inspect-proxy-A3OROWPG.js");
         stopAllInspectProxies();
         const { cleanupAllProcesses } = await import("./store-JYPZ2RXB.js");
         cleanupAllProcesses();
@@ -8646,4 +9618,4 @@ export {
   createServerHandle,
   createServer
 };
-//# sourceMappingURL=chunk-ZXWJ6JTL.js.map
+//# sourceMappingURL=chunk-6MUSEPV7.js.map