openfox 2.0.129 → 2.0.130

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 2.0.130 - 2026-08-28
+
+### Features
+
+- **Drive OpenFox sessions from any MCP client** — a built-in MCP server exposes `openfox_*` tools to run agents, manage sessions and workflows, plus an `openfox mcp` command that prints a paste-ready client config
+- **Merge multi-mode model variants into a single model** — OmniRoute-style families (`*-low/-medium/-high`) collapse into one model with mode chips, mapped to the right provider ID per effort
+- **Agent sees tool and prompt changes instantly** — system-reminder diffs are injected at the point of contention mid-session
+- **Header icons collapse into a mobile menu** — cleaner navigation on small screens
+- **New plugin registry entries** — openfox-openrouter-free and openfox-opencode-free
+
+### Enhancements
+
+- **Full reasoning-effort control on OpenAI gpt-5** — tools and effort work together via the Responses API, no more forced "none"
+- **Vision-capable models get an eye indicator** — auto-detected from the backend and shown across the model lists
+- **MCP tool changes previewed in the system prompt** — the preview lists exactly which tools were added/removed
+- **OAuth authorize completes instantly in the UI** — the callback tab notifies the app via BroadcastChannel, no paste-back needed
+
+### Bug Fixes
+
+- **OpenAI provider no longer fails LLM calls** — gpt-5.x uses max_completion_tokens, thinking no longer sends chat_template_kwargs, and api.openai.com/anthropic.com providers auto-detect their backend without a re-save
+- **OpenCode Go Responses-API models now work** — gpt-5.6-luna, grok-4.6 and muse-spark route to /v1/responses instead of the rejecting chat endpoint
+- **Responses routing is backend-aware** — vLLM, Ollama and friends never hit /v1/responses
+- **Session list no longer shrinks after delete/rename/favorite** — reloads are scoped to the active project
+- **Session history defaults to a 300-message limit** — fresh installs no longer send unlimited history; explicit 0 stays opt-in unlimited
+- **Logout actually logs out** — clears the token, closes the WebSocket and stops auto-reconnect
+- **MCP OAuth reconnects no longer clobber pending authorizations** — background probes use in-memory state; stale client registrations are auto-detected and cleared
+- **MCP server list refreshes reliably in the UI** — the tools tab updates immediately after server changes
+- **Sub-agent window no longer shows the main session's compaction badge** — and no longer overlaps on narrow panes
+- **No more false path confirmations from heredoc bodies** — path extraction ignores heredocs
+- **Removed fake provider-defaults fields** — dead thinking/non-thinking params are gone, pointing to the real per-model settings
+- **Merged mode-chip models survive catalog refresh** — no re-expanding after a re-fetch
+
 ## 2.0.129 - 2026-08-25
 
 ### Features

package/README.md

@@ -100,6 +100,8 @@ Restart OpenFox after installing or updating a plugin.
 - To authenticate with a Github copilot account, you can install the [`openfox-github-copilot`](https://github.com/JamesDAdams/openfox-github-copilot) plugin.
 - To authenticate with a Google Antigravity account, you can install the [`openfox-google-antigravity`](https://github.com/JamesDAdams/openfox-google-antigravity) plugin.
 - To authenticate with an X (xAI) SuperGrok subscription, you can install the [`openfox-xai-supergrok`](https://github.com/Olgean-Group/openfox-xai-supergrok) plugin.
+- To use free OpenRouter models, you can install the [`openfox-openrouter-free`](https://github.com/JamesDAdams/openfox-openrouter-free) plugin.
+- To use free OpenCode models, you can install the [`openfox-opencode-free`](https://github.com/JamesDAdams/openfox-opencode-free) plugin.
 
 ## Screenshots
 

package/dist/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 2.0.130 - 2026-08-28
+
+### Features
+
+- **Drive OpenFox sessions from any MCP client** — a built-in MCP server exposes `openfox_*` tools to run agents, manage sessions and workflows, plus an `openfox mcp` command that prints a paste-ready client config
+- **Merge multi-mode model variants into a single model** — OmniRoute-style families (`*-low/-medium/-high`) collapse into one model with mode chips, mapped to the right provider ID per effort
+- **Agent sees tool and prompt changes instantly** — system-reminder diffs are injected at the point of contention mid-session
+- **Header icons collapse into a mobile menu** — cleaner navigation on small screens
+- **New plugin registry entries** — openfox-openrouter-free and openfox-opencode-free
+
+### Enhancements
+
+- **Full reasoning-effort control on OpenAI gpt-5** — tools and effort work together via the Responses API, no more forced "none"
+- **Vision-capable models get an eye indicator** — auto-detected from the backend and shown across the model lists
+- **MCP tool changes previewed in the system prompt** — the preview lists exactly which tools were added/removed
+- **OAuth authorize completes instantly in the UI** — the callback tab notifies the app via BroadcastChannel, no paste-back needed
+
+### Bug Fixes
+
+- **OpenAI provider no longer fails LLM calls** — gpt-5.x uses max_completion_tokens, thinking no longer sends chat_template_kwargs, and api.openai.com/anthropic.com providers auto-detect their backend without a re-save
+- **OpenCode Go Responses-API models now work** — gpt-5.6-luna, grok-4.6 and muse-spark route to /v1/responses instead of the rejecting chat endpoint
+- **Responses routing is backend-aware** — vLLM, Ollama and friends never hit /v1/responses
+- **Session list no longer shrinks after delete/rename/favorite** — reloads are scoped to the active project
+- **Session history defaults to a 300-message limit** — fresh installs no longer send unlimited history; explicit 0 stays opt-in unlimited
+- **Logout actually logs out** — clears the token, closes the WebSocket and stops auto-reconnect
+- **MCP OAuth reconnects no longer clobber pending authorizations** — background probes use in-memory state; stale client registrations are auto-detected and cleared
+- **MCP server list refreshes reliably in the UI** — the tools tab updates immediately after server changes
+- **Sub-agent window no longer shows the main session's compaction badge** — and no longer overlaps on narrow panes
+- **No more false path confirmations from heredoc bodies** — path extraction ignores heredocs
+- **Removed fake provider-defaults fields** — dead thinking/non-thinking params are gone, pointing to the real per-model settings
+- **Merged mode-chip models survive catalog refresh** — no re-expanding after a re-fetch
+
 ## 2.0.129 - 2026-08-25
 
 ### Features

package/dist/auth-D3WLIBTG.js

@@ -0,0 +1,19 @@
+import {
+  authConfigExists,
+  encryptPassword,
+  hashPassword,
+  loadAuthConfig,
+  saveAuthConfig,
+  verifyPassword
+} from "./chunk-CQGJ5RWB.js";
+import "./chunk-CQGTEGKL.js";
+import "./chunk-YLJ4XMA6.js";
+export {
+  authConfigExists,
+  encryptPassword,
+  hashPassword,
+  loadAuthConfig,
+  saveAuthConfig,
+  verifyPassword
+};
+//# sourceMappingURL=auth-D3WLIBTG.js.map

package/dist/{auto-config-454YE6KC.js → auto-config-5VSNLVNI.js}

@@ -1,12 +1,13 @@
 import {
-  findLmStudioModel
-} from "./chunk-K2QKX4ZJ.js";
+  findLmStudioModel,
+  hasVisionEvidence
+} from "./chunk-OA2FURC3.js";
 import {
   ensureVersionPrefix
 } from "./chunk-HNCM3D7Y.js";
 import {
   getCatalogEntry
-} from "./chunk-ISE55FOR.js";
+} from "./chunk-2AI7VYPN.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -99,7 +100,7 @@ async function detectOllamaInfo(baseUrl, modelId) {
   const mi = data.model_info ?? {};
   const ctxKey = Object.keys(mi).find((k) => k.endsWith(".context_length") || k === "context_length");
   const ctxLen = ctxKey ? Number(mi[ctxKey]) : void 0;
-  const supportsVision = !!mi["vision_start_token_id"] || Object.keys(mi).some((k) => k.includes(".vision."));
+  const supportsVision = hasVisionEvidence(mi);
   if (ctxLen && !isNaN(ctxLen)) {
     return { contextWindow: ctxLen, source: "backend", supportsVision };
   }
@@ -307,4 +308,4 @@ async function autoConfig(input) {
 export {
   autoConfig
 };
-//# sourceMappingURL=auto-config-454YE6KC.js.map
+//# sourceMappingURL=auto-config-5VSNLVNI.js.map

package/dist/{backend-4YPEC3J2.js → backend-NDBY3DAQ.js}

@@ -1,10 +1,12 @@
 import {
+  detectBackendFromUrl,
   getBackendCapabilities,
   getBackendDisplayName
-} from "./chunk-PBFGJFGC.js";
+} from "./chunk-UV6IH6HK.js";
 import "./chunk-YLJ4XMA6.js";
 export {
+  detectBackendFromUrl,
   getBackendCapabilities,
   getBackendDisplayName
 };
-//# sourceMappingURL=backend-4YPEC3J2.js.map
+//# sourceMappingURL=backend-NDBY3DAQ.js.map

package/dist/{chat-handler-TH6JBO6G.js → chat-handler-4WCKNCQV.js}

@@ -2,55 +2,55 @@ import {
   buildRunChatTurnParams,
   finalizeTurnCompletion,
   generateSessionNameForSession
-} from "./chunk-OHTBWA7L.js";
+} from "./chunk-35GQEIH2.js";
 import {
   runChatTurn
-} from "./chunk-7RIEI2TE.js";
-import "./chunk-L24A6GZ7.js";
-import "./chunk-PHP7PLFX.js";
-import "./chunk-ZIL6VKLU.js";
-import "./chunk-6LX43YRA.js";
-import "./chunk-GIJUWPRQ.js";
+} from "./chunk-EVVWDRM5.js";
+import "./chunk-X24XN2M2.js";
+import "./chunk-Y3BSBKHY.js";
+import "./chunk-J7GAZGZT.js";
+import "./chunk-JSONBGSY.js";
+import "./chunk-ZRCRGPGT.js";
+import "./chunk-7ET46SNE.js";
 import "./chunk-EHFIUXWZ.js";
-import "./chunk-RV5G7QQU.js";
+import "./chunk-DQTXXHD2.js";
 import "./chunk-I72ACQ6R.js";
 import "./chunk-JE7LW7Y6.js";
 import "./chunk-OAN4BXEW.js";
-import "./chunk-Y3BSBKHY.js";
-import "./chunk-J7GAZGZT.js";
-import "./chunk-H6YIVK67.js";
-import "./chunk-7YP4O4XE.js";
-import "./chunk-26WS7AH6.js";
+import "./chunk-25DAVVTP.js";
+import "./chunk-64N4CZFT.js";
+import "./chunk-CGCEAKG5.js";
+import "./chunk-JURM3RPZ.js";
+import "./chunk-VJNA5AOB.js";
 import {
   getEventStore
-} from "./chunk-YJD5A375.js";
-import "./chunk-ZIYETXOW.js";
-import "./chunk-AQBRI7TM.js";
+} from "./chunk-AYCB32NI.js";
+import "./chunk-JKRMMNUR.js";
+import "./chunk-X3FHIDLT.js";
+import "./chunk-JHA2SPCU.js";
+import "./chunk-OSXPQSLW.js";
 import {
   createChatMessageMessage,
   createPhaseChangedMessage,
   createSessionRunningMessage
-} from "./chunk-567L5OJ6.js";
-import "./chunk-66MG44TF.js";
-import "./chunk-JURM3RPZ.js";
+} from "./chunk-P57IBMK4.js";
 import "./chunk-LCLH6ZUL.js";
-import "./chunk-JQMQ4DGC.js";
-import "./chunk-K2QKX4ZJ.js";
+import "./chunk-6QZVAOSA.js";
+import "./chunk-CYQUM42E.js";
+import "./chunk-OA2FURC3.js";
 import "./chunk-J2GP3J3X.js";
-import "./chunk-KBESUA3W.js";
-import "./chunk-OSXPQSLW.js";
 import "./chunk-3B232XG4.js";
-import "./chunk-P6GTPKE5.js";
-import "./chunk-7ZMOP5LS.js";
-import "./chunk-PBFGJFGC.js";
+import "./chunk-DHDIKVRT.js";
+import "./chunk-TS5WKTFB.js";
+import "./chunk-UV6IH6HK.js";
 import "./chunk-HNCM3D7Y.js";
-import "./chunk-DABWCAXS.js";
-import "./chunk-ZFNBATE3.js";
-import "./chunk-N2Q3KYWM.js";
+import "./chunk-EUOWCVU6.js";
+import "./chunk-OXMOKQPW.js";
+import "./chunk-3DZSHRXE.js";
 import "./chunk-OYBUJIC3.js";
-import "./chunk-ISE55FOR.js";
+import "./chunk-2AI7VYPN.js";
 import "./chunk-K44MW7JJ.js";
-import "./chunk-ATWOXI52.js";
+import "./chunk-HCYSGLY2.js";
 import "./chunk-R5FAEKXQ.js";
 import "./chunk-CQGTEGKL.js";
 import "./chunk-YLJ4XMA6.js";
@@ -174,4 +174,4 @@ export {
   startChatSession,
   stopSessionExecution
 };
-//# sourceMappingURL=chat-handler-TH6JBO6G.js.map
+//# sourceMappingURL=chat-handler-4WCKNCQV.js.map

package/dist/chunk-25DAVVTP.js

@@ -0,0 +1,395 @@
+import {
+  getAllInstructions,
+  getEnabledSkillMetadata
+} from "./chunk-64N4CZFT.js";
+import {
+  buildTopLevelSystemPrompt
+} from "./chunk-CGCEAKG5.js";
+import {
+  getCurrentContextWindowId,
+  getEventStore
+} from "./chunk-AYCB32NI.js";
+import {
+  findAgentById,
+  getRuntimeConfig,
+  getSubAgents,
+  loadAllAgentsDefault,
+  resolveDefaultAgentId
+} from "./chunk-JHA2SPCU.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+import {
+  getGlobalConfigDir
+} from "./chunk-CQGTEGKL.js";
+
+// src/server/chat/dynamic-context.ts
+import { createHash, randomUUID } from "crypto";
+function computeUnifiedDiff(oldText, newText) {
+  const oldLines = oldText.length === 0 ? [] : oldText.split("\n");
+  const newLines = newText.length === 0 ? [] : newText.split("\n");
+  const result = [];
+  if (oldText === newText) {
+    return oldLines.map((line) => ({ type: "unchanged", content: line }));
+  }
+  const lcs = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 <= oldLines.length; i2++) {
+    lcs.set(i2, /* @__PURE__ */ new Map());
+    for (let j2 = 0; j2 <= newLines.length; j2++) {
+      lcs.get(i2).set(j2, 0);
+    }
+  }
+  for (let i2 = 1; i2 <= oldLines.length; i2++) {
+    for (let j2 = 1; j2 <= newLines.length; j2++) {
+      const oldLine = oldLines[i2 - 1];
+      const newLine = newLines[j2 - 1];
+      if (oldLine === newLine) {
+        lcs.get(i2).set(j2, (lcs.get(i2 - 1).get(j2 - 1) ?? 0) + 1);
+      } else {
+        const up = lcs.get(i2 - 1).get(j2) ?? 0;
+        const left = lcs.get(i2).get(j2 - 1) ?? 0;
+        lcs.get(i2).set(j2, Math.max(up, left));
+      }
+    }
+  }
+  let i = oldLines.length;
+  let j = newLines.length;
+  while (i > 0 || j > 0) {
+    const oldLine = oldLines[i - 1] ?? "";
+    const newLine = newLines[j - 1] ?? "";
+    if (i > 0 && j > 0 && oldLine === newLine) {
+      result.unshift({ type: "unchanged", content: oldLine });
+      i--;
+      j--;
+    } else if (i > 0 && j > 0) {
+      const lcsIM1J = lcs.get(i - 1)?.get(j) ?? 0;
+      const lcsIJM1 = lcs.get(i)?.get(j - 1) ?? 0;
+      if (lcsIM1J > lcsIJM1) {
+        result.unshift({ type: "removed", content: oldLine });
+        i--;
+      } else {
+        result.unshift({ type: "added", content: newLine });
+        j--;
+      }
+    } else if (i > 0) {
+      result.unshift({ type: "removed", content: oldLine });
+      i--;
+    } else {
+      result.unshift({ type: "added", content: newLine });
+      j--;
+    }
+  }
+  return result;
+}
+function computeDynamicContextHash(instructionContent, skills, toolFingerprint, modelName) {
+  const dynamicInputs = JSON.stringify({
+    instructions: instructionContent,
+    skills: skills.map((s) => s.id).sort(),
+    ...toolFingerprint ? { tools: toolFingerprint } : {},
+    ...modelName ? { model: modelName } : {}
+  });
+  return createHash("sha256").update(dynamicInputs).digest("hex");
+}
+function getToolFingerprint(tools) {
+  return tools.map((t) => `${t.function.name}:${JSON.stringify(t.function.parameters)}`).sort().join("|");
+}
+function computeToolDiff(oldTools, newTools) {
+  const oldNames = oldTools.map((t) => t.function.name).sort();
+  const newNames = newTools.map((t) => t.function.name).sort();
+  const oldSet = new Set(oldNames);
+  const newSet = new Set(newNames);
+  const result = [];
+  for (const name of oldNames) {
+    if (!newSet.has(name)) result.push({ type: "removed", content: name });
+  }
+  for (const name of newNames) {
+    if (!oldSet.has(name)) result.push({ type: "added", content: name });
+  }
+  return result;
+}
+function computePreviewToolDiff(oldCachedTools, unfilteredTools, newTools) {
+  const baseline = oldCachedTools && oldCachedTools.length > 0 ? oldCachedTools : unfilteredTools;
+  return computeToolDiff(baseline, newTools);
+}
+var MAX_DESCRIPTION_LENGTH = 80;
+function getToolSignature(tool) {
+  const fn = tool.function;
+  return `${fn.name}:${fn.description ?? ""}:${JSON.stringify(fn.parameters)}`;
+}
+function detectToolChanges(liveTools, cachedTools) {
+  const liveByName = new Map(liveTools.map((t) => [t.function.name, t]));
+  const cachedByName = new Map(cachedTools.map((t) => [t.function.name, t]));
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const name of liveByName.keys()) {
+    const liveTool = liveByName.get(name);
+    const cachedTool = cachedByName.get(name);
+    if (!cachedTool) {
+      const properties = liveTool.function.parameters?.["properties"];
+      added.push({
+        name,
+        description: liveTool.function.description,
+        params: Object.keys(properties ?? {})
+      });
+    } else if (getToolSignature(liveTool) !== getToolSignature(cachedTool)) {
+      changed.push(name);
+    }
+  }
+  for (const name of cachedByName.keys()) {
+    if (!liveByName.has(name)) removed.push(name);
+  }
+  added.sort((a, b) => a.name.localeCompare(b.name));
+  removed.sort();
+  changed.sort();
+  return { added, removed, changed };
+}
+function hasToolChanges(changes) {
+  return changes.added.length > 0 || changes.removed.length > 0 || changes.changed.length > 0;
+}
+function truncateDescription(description) {
+  if (!description) return void 0;
+  const trimmed = description.replace(/\s+/g, " ").trim();
+  if (trimmed.length <= MAX_DESCRIPTION_LENGTH) return trimmed;
+  return trimmed.slice(0, MAX_DESCRIPTION_LENGTH - 1) + "\u2026";
+}
+function formatAddedTool(tool) {
+  const description = truncateDescription(tool.description);
+  const params = tool.params.length > 0 ? ` (params: ${tool.params.join(", ")})` : "";
+  return description ? `${tool.name} \u2014 ${description}${params}` : `${tool.name}${params}`;
+}
+function renderToolChangeReminder(changes) {
+  if (!hasToolChanges(changes)) return null;
+  const sections = [];
+  if (changes.added.length > 0) {
+    sections.push(`Added:
+${changes.added.map(formatAddedTool).join("\n")}`);
+  }
+  if (changes.removed.length > 0) {
+    sections.push(`Removed:
+${changes.removed.join("\n")}`);
+  }
+  if (changes.changed.length > 0) {
+    sections.push(`Changed:
+${changes.changed.join("\n")}`);
+  }
+  return `<system-reminder>
+The available tools have changed since your last turn:
+${sections.join(
+    "\n"
+  )}
+</system-reminder>`;
+}
+var MAX_PROMPT_DIFF_LINES = 40;
+var MAX_PROMPT_DIFF_LINE_LENGTH = 200;
+function renderSystemPromptDiff(oldPrompt, newPrompt) {
+  const diff = computeUnifiedDiff(oldPrompt, newPrompt);
+  const changedLines = diff.filter((line) => line.type !== "unchanged");
+  if (changedLines.length === 0) return null;
+  const visible = changedLines.slice(0, MAX_PROMPT_DIFF_LINES);
+  const lines = visible.map((line) => {
+    const marker = line.type === "added" ? "+" : "-";
+    const content = line.content.length > MAX_PROMPT_DIFF_LINE_LENGTH ? line.content.slice(0, MAX_PROMPT_DIFF_LINE_LENGTH) + "\u2026" : line.content;
+    return `${marker} ${content}`;
+  });
+  const omitted = changedLines.length - visible.length;
+  if (omitted > 0) {
+    lines.push(`\u2026 ${omitted} more line${omitted === 1 ? "" : "s"} omitted`);
+  }
+  return `<system-reminder>
+Your system prompt has changed:
+${lines.join("\n")}
+</system-reminder>`;
+}
+function injectSystemReminder(sessionId, append, content, type, name) {
+  const currentWindowId = getCurrentContextWindowId(sessionId);
+  const reminderMsgId = randomUUID();
+  append({
+    type: "message.start",
+    data: {
+      messageId: reminderMsgId,
+      role: "user",
+      content,
+      ...currentWindowId ? { contextWindowId: currentWindowId } : {},
+      isSystemGenerated: true,
+      messageKind: "auto-prompt",
+      metadata: { type, name, color: "#6b7280", kind: "reminder" }
+    }
+  });
+  append({
+    type: "message.done",
+    data: { messageId: reminderMsgId }
+  });
+}
+async function injectDriftReminders(sessionManager, sessionId, agentDef, options, append) {
+  const cached = sessionManager.getCachedPrompt(sessionId);
+  if (!cached) {
+    return { injectedToolReminder: false, injectedPromptReminder: false };
+  }
+  const { getToolRegistryForAgent } = await import("./tools-SSPC3UQZ.js");
+  const liveTools = getToolRegistryForAgent(agentDef, sessionId).definitions;
+  let injectedToolReminder = false;
+  let injectedPromptReminder = false;
+  const changes = detectToolChanges(liveTools, cached.tools);
+  if (hasToolChanges(changes)) {
+    const reminder = renderToolChangeReminder(changes);
+    if (reminder) {
+      injectSystemReminder(sessionId, append, reminder, "tools", "Tools");
+      injectedToolReminder = true;
+    }
+    const newHash = computeDynamicContextHash(
+      options.instructionContent,
+      options.skills,
+      getToolFingerprint(liveTools),
+      options.modelName
+    );
+    sessionManager.setCachedPrompt(sessionId, cached.systemPrompt, liveTools, newHash);
+  }
+  const livePromptHash = computeDynamicContextHash(
+    options.instructionContent,
+    options.skills,
+    void 0,
+    options.modelName
+  );
+  const announcedPromptHash = sessionManager.getAnnouncedPromptHash(sessionId) ?? cached.hash;
+  if (announcedPromptHash !== livePromptHash) {
+    const reminder = renderSystemPromptDiff(cached.systemPrompt, options.buildNewSystemPrompt());
+    if (reminder) {
+      injectSystemReminder(sessionId, append, reminder, "system-prompt", "System Prompt");
+      injectedPromptReminder = true;
+    }
+    sessionManager.setAnnouncedPromptHash(sessionId, livePromptHash);
+  }
+  return { injectedToolReminder, injectedPromptReminder };
+}
+async function checkToolChangesAndInject(sessionManager, sessionId, agentDef, options, append) {
+  return injectDriftReminders(sessionManager, sessionId, agentDef, options, append);
+}
+function createEventStoreAppend(sessionId) {
+  return (event) => {
+    try {
+      getEventStore().append(sessionId, event);
+    } catch {
+    }
+  };
+}
+function resolveConcreteModelName(sessionManager, sessionId, agentId) {
+  const effective = sessionManager.resolveEffectiveProviderModel(sessionId, agentId);
+  if (effective.providerId && effective.model) {
+    const pm = sessionManager.getProviderManager();
+    const resolvedModel = pm.resolveModel(effective.providerId, effective.model);
+    const effectiveModel = resolvedModel ?? effective.model;
+    const client = pm.createClient(effective.providerId, effectiveModel, effective.reasoningEffort);
+    if (client) return client.getModel();
+  }
+  return sessionManager.getProviderManager().getCurrentModel() ?? "";
+}
+async function injectContextDriftReminders(sessionManager, sessionId, append) {
+  try {
+    const allAgents = await loadAllAgentsDefault(sessionManager.getProjectWorkdir(sessionId));
+    const session = sessionManager.requireSession(sessionId);
+    const agentDef = findAgentById(session.mode, allAgents) ?? findAgentById(resolveDefaultAgentId(), allAgents);
+    const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
+    const subAgentDefs = getSubAgents(allAgents);
+    const modelName = resolveConcreteModelName(sessionManager, sessionId, agentDef.metadata.id);
+    return await injectDriftReminders(
+      sessionManager,
+      sessionId,
+      agentDef,
+      {
+        modelName,
+        instructionContent: instructionContent ?? "",
+        skills,
+        buildNewSystemPrompt: () => buildTopLevelSystemPrompt(session.workdir, instructionContent || void 0, skills, subAgentDefs, modelName)
+      },
+      append ?? createEventStoreAppend(sessionId)
+    );
+  } catch (error) {
+    logger.warn("injectContextDriftReminders failed", {
+      sessionId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return { injectedToolReminder: false, injectedPromptReminder: false };
+  }
+}
+async function injectContextDriftRemindersForSessions(sessionManager, sessionIds) {
+  for (const sessionId of sessionIds) {
+    await injectContextDriftReminders(sessionManager, sessionId);
+  }
+}
+async function loadSessionContext(sessionManager, sessionId) {
+  const session = sessionManager.requireSession(sessionId);
+  const { content: instructionContent } = await getAllInstructions(session.workdir, session.projectId);
+  const runtimeConfig = getRuntimeConfig();
+  const configDir = getGlobalConfigDir(runtimeConfig.mode ?? "production");
+  const skills = await getEnabledSkillMetadata(configDir, sessionManager.getProjectWorkdir(sessionId));
+  return { instructionContent: instructionContent ?? "", skills };
+}
+function resolveAgentDef(sessionManager, sessionId) {
+  return loadAllAgentsDefault(sessionManager.getProjectWorkdir(sessionId)).then((allAgents) => {
+    const session = sessionManager.requireSession(sessionId);
+    return findAgentById(session.mode, allAgents) ?? findAgentById(resolveDefaultAgentId(), allAgents);
+  });
+}
+async function buildCachedPrompt(sessionManager, sessionId, agentDef, modelName) {
+  const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
+  const { getToolRegistryForAgent } = await import("./tools-SSPC3UQZ.js");
+  const tools = getToolRegistryForAgent(agentDef, sessionId).definitions;
+  const toolFingerprint = getToolFingerprint(tools);
+  const allAgents = await loadAllAgentsDefault(sessionManager.getProjectWorkdir(sessionId));
+  const subAgentDefs = getSubAgents(allAgents);
+  const session = sessionManager.requireSession(sessionId);
+  const systemPrompt = buildTopLevelSystemPrompt(
+    session.workdir,
+    instructionContent || void 0,
+    skills,
+    subAgentDefs,
+    modelName
+  );
+  const hash = computeDynamicContextHash(instructionContent, skills, toolFingerprint, modelName);
+  const promptHash = computeDynamicContextHash(instructionContent, skills, void 0, modelName);
+  return { systemPrompt, tools, hash, promptHash };
+}
+async function computeSessionHash(sessionManager, sessionId, modelName) {
+  const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
+  const agentDef = await resolveAgentDef(sessionManager, sessionId);
+  const { getToolRegistryForAgent } = await import("./tools-SSPC3UQZ.js");
+  const tools = getToolRegistryForAgent(agentDef, sessionId).definitions;
+  const toolFingerprint = getToolFingerprint(tools);
+  return computeDynamicContextHash(instructionContent, skills, toolFingerprint, modelName);
+}
+async function applyDynamicContext(sessionManager, sessionId, modelName) {
+  const session = sessionManager.requireSession(sessionId);
+  const allAgents = await loadAllAgentsDefault(sessionManager.getProjectWorkdir(sessionId));
+  const agentDef = findAgentById(session.mode, allAgents) ?? findAgentById(resolveDefaultAgentId(), allAgents);
+  const { systemPrompt, tools, hash, promptHash } = await buildCachedPrompt(
+    sessionManager,
+    sessionId,
+    agentDef,
+    modelName
+  );
+  sessionManager.setCachedPrompt(sessionId, systemPrompt, tools, hash);
+  sessionManager.setAnnouncedPromptHash(sessionId, promptHash);
+  sessionManager.setDynamicContextChanged(sessionId, false);
+  sessionManager.clearDebugDump(sessionId);
+  logger.debug("applyDynamicContext done", { sessionId, hash, toolCount: tools.length });
+}
+
+export {
+  computeUnifiedDiff,
+  computeDynamicContextHash,
+  getToolFingerprint,
+  computeToolDiff,
+  computePreviewToolDiff,
+  getToolSignature,
+  detectToolChanges,
+  renderToolChangeReminder,
+  renderSystemPromptDiff,
+  checkToolChangesAndInject,
+  injectContextDriftReminders,
+  injectContextDriftRemindersForSessions,
+  buildCachedPrompt,
+  computeSessionHash,
+  applyDynamicContext
+};
+//# sourceMappingURL=chunk-25DAVVTP.js.map

package/dist/{chunk-ISE55FOR.js → chunk-2AI7VYPN.js}

@@ -22,6 +22,15 @@ function resolveEffortForModel({
   if (override) return override;
   return defaultEffort && reasoningEfforts.includes(defaultEffort) ? defaultEffort : void 0;
 }
+var MODE_SUFFIXES = ["low", "medium", "high", "xhigh", "max"];
+var MODE_SUFFIX_REGEX = new RegExp(`-(${MODE_SUFFIXES.join("|")})$`);
+function resolveModeModelId(modes, effort, fallbackApiModelId, modelId) {
+  const modeEntry = modes?.find((mode) => mode.level === effort);
+  if (modeEntry) {
+    return { modelId: modeEntry.apiModelId, suppressEffort: true };
+  }
+  return { modelId: fallbackApiModelId ?? modelId, suppressEffort: false };
+}
 
 // src/server/providers/model-catalog.ts
 var CATALOG = [
@@ -83,7 +92,8 @@ export {
   REASONING_EFFORT_VALUES,
   isReasoningEffortValue,
   resolveEffortForModel,
+  resolveModeModelId,
   getCatalogEntry,
   getCatalogDefaultEffort
 };
-//# sourceMappingURL=chunk-ISE55FOR.js.map
+//# sourceMappingURL=chunk-2AI7VYPN.js.map