openfox 2.0.129 → 2.0.131

package/dist/chunk-SVALN5KE.js

@@ -0,0 +1,394 @@
+import {
+  getAllInstructions,
+  getEnabledSkillMetadata
+} from "./chunk-BKMWZTNO.js";
+import {
+  buildTopLevelSystemPrompt
+} from "./chunk-7JVBDBXE.js";
+import {
+  getCurrentContextWindowId,
+  getEventStore
+} from "./chunk-FGNJMKDV.js";
+import {
+  findAgentById,
+  getRuntimeConfig,
+  getSubAgents,
+  loadAllAgentsDefault,
+  resolveDefaultAgentId
+} from "./chunk-ELYHHEYL.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 getToolSetFingerprint(tools) {
+  return tools.map(getToolSignature).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_TOOL_SCHEMA_LINES = 120;
+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) {
+      added.push({ name, tool: liveTool });
+    } else if (getToolSignature(liveTool) !== getToolSignature(cachedTool)) {
+      changed.push({ name, tool: liveTool });
+    }
+  }
+  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((a, b) => a.name.localeCompare(b.name));
+  return { added, removed, changed };
+}
+function hasToolChanges(changes) {
+  return changes.added.length > 0 || changes.removed.length > 0 || changes.changed.length > 0;
+}
+function formatToolDefinition(entry) {
+  const json = JSON.stringify(entry.tool, null, 2);
+  const lines = json.split("\n");
+  if (lines.length <= MAX_TOOL_SCHEMA_LINES) return `### ${entry.name}
+${json}`;
+  const visible = lines.slice(0, MAX_TOOL_SCHEMA_LINES);
+  const omitted = lines.length - visible.length;
+  return `### ${entry.name}
+${visible.join("\n")}
+\u2026 ${omitted} more lines omitted`;
+}
+function renderToolChangeReminder(changes) {
+  if (!hasToolChanges(changes)) return null;
+  const sections = [];
+  if (changes.added.length > 0) {
+    sections.push(`Added:
+${changes.added.map(formatToolDefinition).join("\n")}`);
+  }
+  if (changes.removed.length > 0) {
+    sections.push(`Removed:
+${changes.removed.join("\n")}`);
+  }
+  if (changes.changed.length > 0) {
+    sections.push(`Changed:
+${changes.changed.map(formatToolDefinition).join("\n")}`);
+  }
+  return `<system-reminder>
+The available tools have changed since your last turn. The definitions below are the exact tool schemas now available:
+${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-6BDT5YMT.js");
+  const liveTools = getToolRegistryForAgent(agentDef, sessionId).definitions;
+  let injectedToolReminder = false;
+  let injectedPromptReminder = false;
+  const liveToolFingerprint = getToolSetFingerprint(liveTools);
+  const announcedToolFingerprint = sessionManager.getAnnouncedToolFingerprint(sessionId) ?? getToolSetFingerprint(cached.tools);
+  if (announcedToolFingerprint !== liveToolFingerprint) {
+    const changes = detectToolChanges(liveTools, cached.tools);
+    if (hasToolChanges(changes)) {
+      const reminder = renderToolChangeReminder(changes);
+      if (reminder) {
+        injectSystemReminder(sessionId, append, reminder, "tools", "Tools");
+        injectedToolReminder = true;
+      }
+      sessionManager.setDynamicContextChanged(sessionId, true);
+    }
+    sessionManager.setAnnouncedToolFingerprint(sessionId, liveToolFingerprint);
+  }
+  const livePromptHash = computeDynamicContextHash(
+    options.instructionContent,
+    options.skills,
+    void 0,
+    options.modelName
+  );
+  const announcedPromptHash = sessionManager.getAnnouncedPromptHash(sessionId) ?? cached.promptHash ?? 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-6BDT5YMT.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-6BDT5YMT.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, promptHash);
+  sessionManager.setAnnouncedPromptHash(sessionId, promptHash);
+  sessionManager.setAnnouncedToolFingerprint(sessionId, getToolSetFingerprint(tools));
+  sessionManager.setDynamicContextChanged(sessionId, false);
+  sessionManager.clearDebugDump(sessionId);
+  logger.debug("applyDynamicContext done", { sessionId, hash, toolCount: tools.length });
+}
+
+export {
+  computeUnifiedDiff,
+  computeDynamicContextHash,
+  getToolFingerprint,
+  getToolSetFingerprint,
+  computeToolDiff,
+  computePreviewToolDiff,
+  getToolSignature,
+  detectToolChanges,
+  renderToolChangeReminder,
+  renderSystemPromptDiff,
+  checkToolChangesAndInject,
+  injectContextDriftReminders,
+  injectContextDriftRemindersForSessions,
+  buildCachedPrompt,
+  computeSessionHash,
+  applyDynamicContext
+};
+//# sourceMappingURL=chunk-SVALN5KE.js.map

package/dist/{session-status-6Q5B5PEN.js → chunk-T3S5MTMD.js}

@@ -1,5 +1,3 @@
-import "./chunk-YLJ4XMA6.js";
-
 // src/server/routes/session-status.ts
 var SESSION_STATUS_SCHEMA_VERSION = 1;
 function projectSessionStatus(inputs) {
@@ -28,8 +26,9 @@ function projectSessionStatus(inputs) {
     }
   };
 }
+
 export {
   SESSION_STATUS_SCHEMA_VERSION,
   projectSessionStatus
 };
-//# sourceMappingURL=session-status-6Q5B5PEN.js.map
+//# sourceMappingURL=chunk-T3S5MTMD.js.map

package/dist/{chunk-7YP4O4XE.js → chunk-TACWRDDC.js}

@@ -1,9 +1,9 @@
 import {
   updateSessionMcpDisabledServers
-} from "./chunk-AQBRI7TM.js";
+} from "./chunk-KWAHD2JA.js";
 import {
   getDatabase
-} from "./chunk-OYBUJIC3.js";
+} from "./chunk-JU757HVI.js";
 
 // src/server/mcp/session-overrides.ts
 var sessionOverrides = /* @__PURE__ */ new Map();
@@ -62,4 +62,4 @@ export {
   clearSessionOverrides,
   getAllSessionOverrides
 };
-//# sourceMappingURL=chunk-7YP4O4XE.js.map
+//# sourceMappingURL=chunk-TACWRDDC.js.map

package/dist/{chunk-7ZMOP5LS.js → chunk-TS5WKTFB.js}

@@ -157,6 +157,23 @@ var MODEL_PROFILES = [
       supportsVision: false
     }
   },
+  {
+    pattern: "gpt-5",
+    profile: {
+      name: "GPT-5",
+      // OpenAI's gpt-5 family only accepts temperature = 1 (and top_p = 1);
+      // any other value is rejected with a 400.
+      temperature: 1,
+      topP: 1,
+      defaultMaxTokens: 16384,
+      supportsVision: true,
+      // gpt-5 is a Responses-API family: /v1/chat/completions rejects tools
+      // with any reasoning_effort other than "none", while /v1/responses
+      // supports tools + effort together. Route it there on the openai
+      // backend; on chat completions the request builder clamps the effort.
+      apiProtocol: "responses"
+    }
+  },
   {
     pattern: "gemma-4",
     profile: {
@@ -188,4 +205,4 @@ export {
   getModelProfile,
   modelSupportsVision
 };
-//# sourceMappingURL=chunk-7ZMOP5LS.js.map
+//# sourceMappingURL=chunk-TS5WKTFB.js.map

package/dist/{chunk-PBFGJFGC.js → chunk-UV6IH6HK.js}

@@ -4,60 +4,81 @@ var BACKEND_CAPABILITIES = {
     supportsChatTemplateKwargs: true,
     supportsTopK: true,
     supportsNumCtx: false,
-    routesEffortViaChatTemplateKwargs: false
+    routesEffortViaChatTemplateKwargs: false,
+    usesMaxCompletionTokens: false
   },
   sglang: {
     supportsChatTemplateKwargs: true,
     supportsTopK: true,
     supportsNumCtx: false,
-    routesEffortViaChatTemplateKwargs: false
+    routesEffortViaChatTemplateKwargs: false,
+    usesMaxCompletionTokens: false
   },
   openai: {
     supportsChatTemplateKwargs: false,
     supportsTopK: false,
     supportsNumCtx: false,
-    routesEffortViaChatTemplateKwargs: false
+    routesEffortViaChatTemplateKwargs: false,
+    usesMaxCompletionTokens: true
   },
   anthropic: {
     supportsChatTemplateKwargs: false,
     supportsTopK: false,
     supportsNumCtx: false,
-    routesEffortViaChatTemplateKwargs: false
+    routesEffortViaChatTemplateKwargs: false,
+    usesMaxCompletionTokens: false
   },
   ollama: {
     supportsChatTemplateKwargs: false,
     supportsTopK: false,
     supportsNumCtx: true,
-    routesEffortViaChatTemplateKwargs: false
+    routesEffortViaChatTemplateKwargs: false,
+    usesMaxCompletionTokens: false
   },
   llamacpp: {
     supportsChatTemplateKwargs: false,
     supportsTopK: true,
     supportsNumCtx: false,
-    routesEffortViaChatTemplateKwargs: true
+    routesEffortViaChatTemplateKwargs: true,
+    usesMaxCompletionTokens: false
   },
   lmstudio: {
     supportsChatTemplateKwargs: false,
     supportsTopK: true,
     supportsNumCtx: false,
-    routesEffortViaChatTemplateKwargs: false
+    routesEffortViaChatTemplateKwargs: false,
+    usesMaxCompletionTokens: false
   },
   "opencode-go": {
     supportsChatTemplateKwargs: false,
     supportsTopK: true,
     supportsNumCtx: false,
-    routesEffortViaChatTemplateKwargs: false
+    routesEffortViaChatTemplateKwargs: false,
+    usesMaxCompletionTokens: false
   },
   unknown: {
     supportsChatTemplateKwargs: true,
     supportsTopK: true,
     supportsNumCtx: false,
-    routesEffortViaChatTemplateKwargs: false
+    routesEffortViaChatTemplateKwargs: false,
+    usesMaxCompletionTokens: false
   }
 };
 function getBackendCapabilities(backend) {
   return BACKEND_CAPABILITIES[backend];
 }
+var HOST_BACKEND_MAP = {
+  "api.openai.com": "openai",
+  "api.anthropic.com": "anthropic"
+};
+function detectBackendFromUrl(url) {
+  try {
+    const host = new URL(url).hostname.toLowerCase();
+    return HOST_BACKEND_MAP[host];
+  } catch {
+    return void 0;
+  }
+}
 function getBackendDisplayName(backend) {
   switch (backend) {
     case "vllm":
@@ -83,6 +104,7 @@ function getBackendDisplayName(backend) {
 
 export {
   getBackendCapabilities,
+  detectBackendFromUrl,
   getBackendDisplayName
 };
-//# sourceMappingURL=chunk-PBFGJFGC.js.map
+//# sourceMappingURL=chunk-UV6IH6HK.js.map

package/dist/{chunk-7RIEI2TE.js → chunk-WCM5ZW5N.js}

@@ -4,42 +4,45 @@ import {
   getToolRegistryForAgent,
   processEventsForConversation,
   runTopLevelAgentLoop
-} from "./chunk-L24A6GZ7.js";
+} from "./chunk-5AI3LHRQ.js";
+import {
+  TurnMetrics,
+  createChatDoneEvent,
+  createMessageStartEvent
+} from "./chunk-7ET46SNE.js";
 import {
   buildCachedPrompt,
+  checkToolChangesAndInject,
   computeDynamicContextHash,
   getToolFingerprint
-} from "./chunk-PHP7PLFX.js";
+} from "./chunk-SVALN5KE.js";
 import {
   getAllInstructions,
   getEnabledSkillMetadata
-} from "./chunk-ZIL6VKLU.js";
-import {
-  TurnMetrics,
-  createChatDoneEvent,
-  createMessageStartEvent
-} from "./chunk-6LX43YRA.js";
+} from "./chunk-BKMWZTNO.js";
 import {
   buildAgentReminder,
-  buildAgentSmallReminder
-} from "./chunk-GIJUWPRQ.js";
+  buildAgentSmallReminder,
+  buildTopLevelSystemPrompt
+} from "./chunk-7JVBDBXE.js";
 import {
   PathAccessDeniedError
-} from "./chunk-26WS7AH6.js";
+} from "./chunk-Y6ZGHOKM.js";
 import {
   getCurrentContextWindowId,
   getCurrentWindowMessageOptions,
   getEventStore
-} from "./chunk-YJD5A375.js";
+} from "./chunk-FGNJMKDV.js";
 import {
   buildSnapshotFromSessionState
-} from "./chunk-ZIYETXOW.js";
+} from "./chunk-M5T4RDPJ.js";
 import {
   findAgentById,
   getRuntimeConfig,
+  getSubAgents,
   loadAllAgentsDefault,
   resolveDefaultAgentId
-} from "./chunk-KBESUA3W.js";
+} from "./chunk-ELYHHEYL.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -49,7 +52,7 @@ import {
 
 // src/server/chat/orchestrator.ts
 async function buildRetryPatterns() {
-  const { getSetting, SETTINGS_KEYS } = await import("./settings-VOWWO4VG.js");
+  const { getSetting, SETTINGS_KEYS } = await import("./settings-MDCRNQBY.js");
   const raw = getSetting(SETTINGS_KEYS.RETRY_PATTERNS);
   if (!raw) {
     const oldXmlProtection = getSetting("llm.disableXmlProtection");
@@ -244,6 +247,27 @@ async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
   const runtimeConfig = getRuntimeConfig();
   const configDir = getGlobalConfigDir(runtimeConfig.mode ?? "production");
   const skills = await getEnabledSkillMetadata(configDir, options.sessionManager.getProjectWorkdir(options.sessionId));
+  if (!options.warmup) {
+    const modelName = agentLlmClient.getModel();
+    await checkToolChangesAndInject(
+      options.sessionManager,
+      options.sessionId,
+      agentDef,
+      {
+        modelName,
+        instructionContent: instructionContent ?? "",
+        skills,
+        buildNewSystemPrompt: () => buildTopLevelSystemPrompt(
+          session.workdir,
+          instructionContent || void 0,
+          skills,
+          getSubAgents(allAgents),
+          modelName
+        )
+      },
+      append
+    );
+  }
   return runTopLevelAgentLoop(
     {
       mode: agentId,
@@ -290,7 +314,14 @@ async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
           agentDef,
           agentLlmClient.getModel()
         );
-        options.sessionManager.setCachedPrompt(options.sessionId, result.systemPrompt, result.tools, result.hash);
+        options.sessionManager.setCachedPrompt(
+          options.sessionId,
+          result.systemPrompt,
+          result.tools,
+          result.hash,
+          result.promptHash
+        );
+        options.sessionManager.setAnnouncedPromptHash(options.sessionId, result.promptHash);
         return createAssemblyResult({
           systemPrompt: result.systemPrompt,
           messages: input.messages,
@@ -302,6 +333,10 @@ async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
       getToolRegistry: () => getToolRegistryForAgent(agentDef, options.sessionId),
       getConversationMessages: buildGetConversationMessages(options.sessionId, resolveAgentClient, append),
       injectAgentReminder: () => injectAgentReminder(options.sessionId, agentDef),
+      rebuildCachedContext: async () => {
+        const { applyDynamicContext } = await import("./dynamic-context-Y555VDLA.js");
+        await applyDynamicContext(options.sessionManager, options.sessionId, agentLlmClient.getModel());
+      },
       ...options.initialCompacting ? { initialCompacting: true } : {},
       ...callbacks?.injectKickoff ? { injectKickoff: callbacks.injectKickoff } : {},
       ...callbacks?.onToolExecuted ? { onToolExecuted: callbacks.onToolExecuted } : {},
@@ -329,4 +364,4 @@ export {
   runChatTurn,
   runAgentTurn
 };
-//# sourceMappingURL=chunk-7RIEI2TE.js.map
+//# sourceMappingURL=chunk-WCM5ZW5N.js.map