@cuylabs/agent-core 0.8.0 → 0.9.0

package/dist/index.js

@@ -1,35 +1,18 @@
-import {
-  FileStorage,
-  MemoryStorage,
-  STORAGE_VERSION,
-  SessionManager,
-  buildEntryPath,
-  buildMessagesFromEntries,
-  configureDefaultSessionManager,
-  createMessageEntry,
-  createMetadataEntry,
-  deserializeMessage,
-  extractSessionInfo,
-  generateEntryId,
-  getDataDir,
-  getDefaultSessionManager,
-  getGitRootHash,
-  getLeafId,
-  getProjectId,
-  getProjectSessionsDir,
-  getSessionsDir,
-  parseJSONL,
-  serializeMessage,
-  toJSONL,
-  toJSONLBatch
-} from "./chunk-BDBZ3SLK.js";
 import {
   DEFAULT_MAX_CONCURRENT,
   DEFAULT_MAX_SPAWN_DEPTH,
   DEFAULT_SESSION_TITLE_PREFIX,
   SubAgentTracker,
-  createSubAgentTools
-} from "./chunk-7MUFEN4K.js";
+  createSubAgentTools,
+  discoverAgentProfiles,
+  getProjectAgentsDir,
+  getUserAgentsDir,
+  isMarkdownProfile,
+  parseAgentFrontmatter,
+  parseMarkdownAgent,
+  parseToolSpec,
+  toAgentProfile
+} from "./chunk-JLXG2SH7.js";
 import {
   ToolRegistry,
   defaultRegistry
@@ -39,21 +22,23 @@ import {
   clearCheckpoints,
   createCheckpointManager,
   createTurnTracker
-} from "./chunk-VBWWUHWI.js";
+} from "./chunk-OFDKHNCX.js";
 import {
-  Presets,
   applyPreset,
+  createPreset,
+  filterTools,
+  mergePresets
+} from "./chunk-IYWQOJMQ.js";
+import {
+  Presets,
   careful,
   code,
-  createPreset,
   explore,
-  filterTools,
-  mergePresets,
   plan,
   quick,
   review,
   watch
-} from "./chunk-CAA7FHIH.js";
+} from "./chunk-EKR6PKXU.js";
 import {
   DEFAULT_INSTRUCTION_PATTERNS,
   DEFAULT_MAX_DEPTH,
@@ -75,7 +60,7 @@ import {
   getTemplate,
   loadGlobalInstructions,
   summarizeEnvironment
-} from "./chunk-IVUJDISU.js";
+} from "./chunk-GFTW23FV.js";
 import {
   AgentTurnEngine,
   ContextOverflowError,
@@ -108,15 +93,15 @@ import {
   runToolBatch,
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages
-} from "./chunk-4BDA7DQY.js";
+} from "./chunk-J4QDGZIA.js";
 import {
   LocalSignal
-} from "./chunk-KUVSERLJ.js";
+} from "./chunk-DXFBQMXP.js";
 import {
   createSkillResourceTool,
   createSkillTool,
   createSkillTools
-} from "./chunk-YUUJK53A.js";
+} from "./chunk-RKEW5WXI.js";
 import {
   MAX_BYTES,
   MAX_LINES,
@@ -127,7 +112,7 @@ import {
   formatSize,
   normalizeToolReplayPolicy,
   truncateOutput
-} from "./chunk-P6YF7USR.js";
+} from "./chunk-MHKK374K.js";
 import {
   DEFAULT_EXTERNAL_DIRS,
   DEFAULT_MAX_SCAN_DEPTH,
@@ -142,7 +127,32 @@ import {
   loadSkillContent,
   loadSkillMetadata,
   parseFrontmatter
-} from "./chunk-LRHOS4ZN.js";
+} from "./chunk-SPILYYDF.js";
+import {
+  FileStorage,
+  MemoryStorage,
+  STORAGE_VERSION,
+  SessionManager,
+  buildEntryPath,
+  buildMessagesFromEntries,
+  configureDefaultSessionManager,
+  createMessageEntry,
+  createMetadataEntry,
+  deserializeMessage,
+  extractSessionInfo,
+  generateEntryId,
+  getDataDir,
+  getDefaultSessionManager,
+  getGitRootHash,
+  getLeafId,
+  getProjectId,
+  getProjectSessionsDir,
+  getSessionsDir,
+  parseJSONL,
+  serializeMessage,
+  toJSONL,
+  toJSONLBatch
+} from "./chunk-UHCJEM2E.js";
 import {
   ContextManager,
   DEFAULT_CONTEXT_LIMITS,
@@ -177,35 +187,23 @@ import {
   streamOnce,
   streamStep,
   withRetry
-} from "./chunk-N6HWIEEA.js";
+} from "./chunk-WKHDSSXG.js";
 import {
   executeAgentToolCall
-} from "./chunk-7VKQ4WPB.js";
+} from "./chunk-H3FUYU52.js";
 import {
   extractFilePathsFromArgs,
   shouldCaptureBaseline,
   withFileTracking
 } from "./chunk-VEKUXUVF.js";
 import {
-  EXTENDED_LEVELS,
-  FIXED_LEVELS,
-  STANDARD_LEVELS,
-  buildAnthropicOptions,
-  buildBedrockOptions,
-  buildGoogleOptions,
-  buildGroqOptions,
-  buildOpenAIOptions,
-  buildOpenRouterOptions,
-  buildReasoningOptions,
-  buildReasoningOptionsSync,
-  buildXAIOptions,
-  getProviderOptionsKey,
-  getReasoningConfig,
-  getReasoningConfigSync,
-  shouldIncludeReasoningSummary,
-  supportsReasoning,
-  supportsReasoningSync
-} from "./chunk-SQU2AJHO.js";
+  LLMError,
+  getErrorCategory,
+  getRetryDelay,
+  isRetryable,
+  isRetryableCategory,
+  parseRetryDelay
+} from "./chunk-4QFNWPIF.js";
 import {
   createScope,
   currentScope,
@@ -214,14 +212,6 @@ import {
   streamWithinScope,
   withinScope
 } from "./chunk-N7P4PN3O.js";
-import {
-  LLMError,
-  getErrorCategory,
-  getRetryDelay,
-  isRetryable,
-  isRetryableCategory,
-  parseRetryDelay
-} from "./chunk-RZITT45F.js";
 import {
   createMCPManager,
   defineServer,
@@ -235,39 +225,187 @@ import {
   createTelemetryConfig,
   otelMiddleware,
   promptCacheMiddleware
-} from "./chunk-YSLSEQ6B.js";
+} from "./chunk-MAZ5DY5B.js";
 import {
   ApprovalDeniedError,
   ApprovalTimeoutError,
   createApprovalHandler,
   getToolRisk
-} from "./chunk-BFM2YHNM.js";
+} from "./chunk-5ARZJWD2.js";
 import {
   CacheCapabilitySource,
   CapabilityCache,
-  DEFAULT_RESOLVER_OPTIONS,
+  EXTENDED_LEVELS,
+  FIXED_LEVELS,
   ModelCapabilityResolver,
-  PatternCapabilitySource,
   RemoteCapabilityFetcher,
   RemoteCapabilitySource,
-  SourcePriority,
+  STANDARD_LEVELS,
   applyCapabilityOverride,
+  buildAnthropicOptions,
+  buildBedrockOptions,
+  buildGoogleOptions,
+  buildGroqOptions,
+  buildOpenAIOptions,
+  buildOpenRouterOptions,
+  buildReasoningOptions,
+  buildReasoningOptionsSync,
+  buildXAIOptions,
   configureResolver,
   createResolver,
-  extractModelId,
-  extractProvider,
   findCapabilityOverride,
   getDefaultResolver,
   getNetworkStatus,
+  getProviderOptionsKey,
+  getReasoningConfig,
+  getReasoningConfigSync,
+  shouldIncludeReasoningSummary,
+  supportsReasoning,
+  supportsReasoningSync
+} from "./chunk-UDCZ673N.js";
+import {
+  DEFAULT_RESOLVER_OPTIONS,
+  PatternCapabilitySource,
+  SourcePriority,
+  extractModelId,
+  extractProvider,
+  getModelId,
   getProviderCompatibility,
+  getProviderId,
   inferContextWindow,
   inferProvider,
   likelySupportsReasoning
-} from "./chunk-RFEKJKTO.js";
+} from "./chunk-I6PKJ7XQ.js";
 import {
-  getModelId,
-  getProviderId
-} from "./chunk-DWYX7ASF.js";
+  LayeredSettings,
+  NullSettings,
+  PluginEventBus,
+  PluginRegistry,
+  StaticSettings,
+  ValidatedSettings,
+  definePlugin,
+  discoverPlugins,
+  getPluginLoader,
+  isDefinedPlugin,
+  loadPluginModule,
+  resetFrameworkAliases,
+  resetPluginLoader,
+  resolveFrameworkAliases
+} from "./chunk-WGZAPU6N.js";
+
+// src/agent/intervention.ts
+var InterventionController = class {
+  /** Immediate interventions — applied at the next step boundary */
+  immediate = [];
+  /** Deferred messages — held until the turn completes */
+  deferred = [];
+  /**
+   * Callback fired when an intervention is wired into a step.
+   * Set by the Agent before starting a chat turn, cleared after.
+   */
+  onApplied;
+  // ---------------------------------------------------------------------------
+  // Immediate interventions (mid-turn redirect)
+  // ---------------------------------------------------------------------------
+  /**
+   * Inject a message at the next LLM step boundary.
+   *
+   * The message is appended as a user message to the conversation
+   * before the next LLM call in the current multi-step turn. The
+   * LLM will see it and can adjust its behavior accordingly.
+   *
+   * Safe to call from any async context while `chat()` is running.
+   * If called when no turn is active, the message will be picked up
+   * by the first step of the next `chat()` call.
+   *
+   * @param message - The user message to inject
+   * @returns Intervention ID for tracking
+   */
+  intervene(message) {
+    const id = crypto.randomUUID();
+    this.immediate.push(
+      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
+    );
+    return id;
+  }
+  /**
+   * Drain and return all pending immediate interventions.
+   * The internal queue is cleared atomically.
+   *
+   * @internal Called by the LLM stream's `prepareStep` hook
+   */
+  drainImmediate() {
+    if (this.immediate.length === 0) return [];
+    return this.immediate.splice(0);
+  }
+  /** Adopt existing immediate interventions without changing their IDs. */
+  adoptImmediate(items) {
+    if (items.length === 0) return;
+    this.immediate.push(...items);
+  }
+  /** Whether there are pending immediate interventions */
+  get hasPending() {
+    return this.immediate.length > 0;
+  }
+  /** Number of pending immediate interventions */
+  get pendingCount() {
+    return this.immediate.length;
+  }
+  // ---------------------------------------------------------------------------
+  // Deferred messages (after-turn follow-ups)
+  // ---------------------------------------------------------------------------
+  /**
+   * Queue a message for after the current turn completes.
+   *
+   * Unlike `intervene()`, this does **not** inject mid-turn. The
+   * message is held and available via `drainDeferred()` after
+   * `chat()` finishes. The consumer decides whether to send it
+   * as a new turn.
+   *
+   * @param message - The message to queue
+   * @returns Intervention ID for tracking
+   */
+  queueNext(message) {
+    const id = crypto.randomUUID();
+    this.deferred.push(
+      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
+    );
+    return id;
+  }
+  /**
+   * Drain and return all deferred messages.
+   * The internal queue is cleared atomically.
+   */
+  drainDeferred() {
+    if (this.deferred.length === 0) return [];
+    return this.deferred.splice(0);
+  }
+  /** Adopt existing deferred interventions without changing their IDs. */
+  adoptDeferred(items) {
+    if (items.length === 0) return;
+    this.deferred.push(...items);
+  }
+  /** Whether there are deferred messages */
+  get hasDeferred() {
+    return this.deferred.length > 0;
+  }
+  /** Number of deferred messages */
+  get deferredCount() {
+    return this.deferred.length;
+  }
+  // ---------------------------------------------------------------------------
+  // Housekeeping
+  // ---------------------------------------------------------------------------
+  /** Clear all queues (immediate + deferred) */
+  clear() {
+    this.immediate.length = 0;
+    this.deferred.length = 0;
+  }
+  /** Reset the controller for a new turn (clears onApplied, keeps queues) */
+  resetCallbacks() {
+    this.onApplied = void 0;
+  }
+};
 
 // src/agent/chat-loop/commit.ts
 function createChatLoopCommitBatchApplier(params) {
@@ -288,14 +426,240 @@ function createChatLoopCommitBatchApplier(params) {
   };
 }
 
+// src/agent/session.ts
+async function ensureSessionLoaded(options) {
+  const { sessionId, sessions, cwd } = options;
+  if (sessions.getSessionId() === sessionId) {
+    return;
+  }
+  const exists = await sessions.sessionExists(sessionId);
+  if (exists) {
+    await sessions.load(sessionId);
+  } else {
+    await sessions.create({ id: sessionId, cwd });
+  }
+}
+async function repairOrphanedToolCalls(sessions) {
+  const messages = sessions.getMessages();
+  const pendingCallIds = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role === "assistant" && message.toolCalls) {
+      for (const toolCall of message.toolCalls) {
+        pendingCallIds.set(toolCall.toolCallId, { toolName: toolCall.toolName });
+      }
+    }
+    if (message.role === "tool" && message.toolCallId) {
+      pendingCallIds.delete(message.toolCallId);
+    }
+  }
+  for (const [toolCallId, { toolName }] of pendingCallIds) {
+    const toolMessage = {
+      id: crypto.randomUUID(),
+      role: "tool",
+      content: "Error: tool execution failed (result was not recorded)",
+      toolCallId,
+      toolName,
+      result: "Error: tool execution failed (result was not recorded)",
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await sessions.addMessage(toolMessage);
+  }
+}
+async function createSubAgentRunSession(options) {
+  const sessionId = options.parentSessionId ? `${options.parentSessionId}:sub:${crypto.randomUUID().slice(0, 8)}` : `sub:${crypto.randomUUID().slice(0, 8)}`;
+  await options.sessions.create({
+    id: sessionId,
+    cwd: options.cwd,
+    title: options.title ?? "Sub-agent task",
+    parentSessionId: options.parentSessionId
+  });
+  return sessionId;
+}
+function getVisibleSessionMessages(sessions) {
+  const leafId = sessions.getLeafId();
+  if (!leafId) {
+    return [];
+  }
+  const path = buildEntryPath(
+    sessions.getEntries(),
+    leafId
+  );
+  const visible = [];
+  let skipUntilId;
+  for (const entry of path) {
+    if (entry.type === "compaction") {
+      visible.push({
+        message: {
+          id: entry.id,
+          role: "system",
+          content: `## Previous Conversation Summary
+
+${entry.summary}`,
+          createdAt: new Date(entry.timestamp)
+        }
+      });
+      skipUntilId = entry.firstKeptEntryId;
+      continue;
+    }
+    if (skipUntilId && entry.id !== skipUntilId) {
+      continue;
+    }
+    if (entry.id === skipUntilId) {
+      skipUntilId = void 0;
+    }
+    if (entry.type === "message") {
+      visible.push({
+        message: deserializeMessage(entry.message)
+      });
+    }
+  }
+  return visible;
+}
+
+// src/agent/runtime-config.ts
+function createAgentToolRecord(tools) {
+  const toolRecord = {};
+  for (const [id, tool] of tools) {
+    toolRecord[id] = tool;
+  }
+  return toolRecord;
+}
+function getAgentContextStats(contextManager, messages) {
+  return contextManager.getStats(messages);
+}
+function buildFallbackCompactionSummary(messages) {
+  const excerpt = messages.map((message) => {
+    const role = message.role.toUpperCase();
+    const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+    return `[${role}] ${content}`;
+  }).join("\n\n");
+  const trimmed = excerpt.length > 8e3 ? `${excerpt.slice(0, 8e3)}
+
+...[truncated during compaction]` : excerpt;
+  return trimmed.length > 0 ? trimmed : "Earlier conversation context was compacted.";
+}
+async function compactAgentContext(options) {
+  const { contextManager, sessions } = options;
+  const visibleMessages = getVisibleSessionMessages(sessions);
+  const messages = visibleMessages.map((item) => item.message);
+  if (!contextManager.shouldPrune(messages)) {
+    return {
+      removedCount: 0,
+      tokensRemoved: 0,
+      summarized: false,
+      summary: void 0
+    };
+  }
+  const tokensBefore = estimateConversationTokens(messages);
+  let removedCount = 0;
+  let summarized = false;
+  let summary;
+  try {
+    const result = await contextManager.prune(messages);
+    removedCount = result.removedCount;
+    summarized = result.summarized;
+    summary = result.summary;
+  } catch {
+  }
+  if (removedCount === 0) {
+    removedCount = findCutPoint(
+      messages,
+      contextManager.getLimits().protectedTokens
+    );
+  }
+  if (removedCount === 0) {
+    return {
+      removedCount: 0,
+      tokensRemoved: 0,
+      summarized: false,
+      summary: void 0
+    };
+  }
+  const summaryText = summary ?? buildFallbackCompactionSummary(messages.slice(0, removedCount));
+  const keptMessages = messages.slice(removedCount);
+  const persistedMessages = [
+    {
+      id: "compaction-preview",
+      role: "system",
+      content: `## Previous Conversation Summary
+
+${summaryText}`,
+      createdAt: /* @__PURE__ */ new Date()
+    },
+    ...keptMessages
+  ];
+  const tokensAfter = estimateConversationTokens(persistedMessages);
+  await sessions.replaceWithCompaction({
+    summary: summaryText,
+    messages: keptMessages,
+    tokensBefore,
+    tokensAfter
+  });
+  return {
+    removedCount,
+    tokensRemoved: Math.max(0, tokensBefore - tokensAfter),
+    summarized,
+    summary: summaryText
+  };
+}
+async function buildAgentSystemPrompts(options) {
+  const {
+    config,
+    toolIds,
+    sessionId,
+    override,
+    promptBuilder,
+    middlewareRunner
+  } = options;
+  if (promptBuilder) {
+    const composedPrompt = await promptBuilder.build(
+      {
+        cwd: config.cwd,
+        model: config.model,
+        toolNames: toolIds,
+        ...override ? { override } : {},
+        sessionId
+      },
+      middlewareRunner
+    );
+    return [composedPrompt];
+  }
+  const prompts = [config.systemPrompt];
+  if (override) {
+    prompts.push(override);
+  }
+  return prompts;
+}
+function createAgentTurnRuntimeConfig(options) {
+  const { config, telemetrySettings } = options;
+  return {
+    model: config.model,
+    cwd: config.cwd,
+    ...config.temperature !== void 0 ? { temperature: config.temperature } : {},
+    ...config.topP !== void 0 ? { topP: config.topP } : {},
+    ...config.maxOutputTokens !== void 0 ? { maxOutputTokens: config.maxOutputTokens } : {},
+    maxSteps: config.maxSteps,
+    ...config.doomLoopThreshold !== void 0 ? { doomLoopThreshold: config.doomLoopThreshold } : {},
+    ...config.enforceDoomLoop !== void 0 ? { enforceDoomLoop: config.enforceDoomLoop } : {},
+    ...config.onDoomLoop ? { onDoomLoop: config.onDoomLoop } : {},
+    ...config.contextWindow !== void 0 ? { contextWindow: config.contextWindow } : {},
+    ...config.streamProvider ? { streamProvider: config.streamProvider } : {},
+    ...telemetrySettings ? { telemetry: telemetrySettings } : {}
+  };
+}
+
 // src/agent/chat-loop/compaction.ts
 async function runAutoCompaction(params) {
-  const { contextManager, messages } = params;
+  const { contextManager, sessions } = params;
+  const messages = sessions.getMessages();
   if (!contextManager.shouldPrune(messages)) {
     return [];
   }
   const events = [{ type: "status", status: "processing" }];
-  const pruneResult = await contextManager.prune(messages);
+  const pruneResult = await compactAgentContext({
+    contextManager,
+    sessions
+  });
   if (pruneResult.removedCount > 0 || pruneResult.summarized) {
     const limits = contextManager.getLimits();
     events.push({
@@ -309,32 +673,14 @@ async function runAutoCompaction(params) {
 
 // src/agent/chat-loop/prompts.ts
 async function buildChatSystemPrompts(params) {
-  const {
-    promptBuilder,
-    middlewareRunner,
-    systemOverride,
-    sessionId,
-    config,
-    tools
-  } = params;
-  if (promptBuilder) {
-    const composedPrompt = await promptBuilder.build(
-      {
-        cwd: config.cwd,
-        model: config.model,
-        toolNames: Object.keys(tools),
-        override: systemOverride,
-        sessionId
-      },
-      middlewareRunner
-    );
-    return [composedPrompt];
-  }
-  const prompts = [config.systemPrompt];
-  if (systemOverride) {
-    prompts.push(systemOverride);
-  }
-  return prompts;
+  return buildAgentSystemPrompts({
+    config: params.config,
+    toolIds: Object.keys(params.tools),
+    sessionId: params.sessionId,
+    override: params.systemOverride,
+    promptBuilder: params.promptBuilder,
+    middlewareRunner: params.middlewareRunner
+  });
 }
 
 // src/agent/chat-loop/usage.ts
@@ -483,7 +829,7 @@ async function* runChatLoop(deps) {
         if (config.compaction?.auto !== false) {
           const compactionEvents = await runAutoCompaction({
             contextManager,
-            messages: sessions.getMessages()
+            sessions
           });
           for (const event of compactionEvents) {
             yield event;
@@ -513,6 +859,12 @@ async function* runChatLoop(deps) {
         };
       } catch (error) {
         chatError = error instanceof Error ? error : new Error(String(error));
+        const statusEvent = { type: "status", status: "error" };
+        middlewareRunner.emitEvent(statusEvent);
+        yield statusEvent;
+        const errorEvent = { type: "error", error: chatError };
+        middlewareRunner.emitEvent(errorEvent);
+        yield errorEvent;
         throw error;
       } finally {
         setIsStreaming(false);
@@ -552,255 +904,100 @@ function resolveChildPromptConfig(options) {
   if (promptBuilder) {
     return { prompt: parentPromptConfig ?? {} };
   }
-  return { systemPrompt: parentSystemPrompt };
-}
-function resolveForkMiddleware(options, middlewareRunner) {
-  if (options.middleware) {
-    return options.middleware;
-  }
-  if (options.additionalMiddleware) {
-    return [
-      ...middlewareRunner.getMiddleware(),
-      ...options.additionalMiddleware
-    ];
-  }
-  return [...middlewareRunner.getMiddleware()];
-}
-function createForkedAgentConfig(options) {
-  const {
-    forkOptions,
-    parentConfig,
-    parentTools,
-    reasoningLevel,
-    host,
-    sessions,
-    mcpManager,
-    middlewareRunner,
-    promptBuilder
-  } = options;
-  const tools = forkOptions.tools ?? parentTools;
-  const childPrompt = resolveChildPromptConfig({
-    forkOptions,
-    promptBuilder,
-    parentPromptConfig: parentConfig.prompt,
-    parentSystemPrompt: parentConfig.systemPrompt
-  });
-  return {
-    model: forkOptions.model ?? parentConfig.model,
-    cwd: parentConfig.cwd,
-    host,
-    maxOutputTokens: parentConfig.maxOutputTokens,
-    maxSteps: forkOptions.maxSteps ?? parentConfig.maxSteps,
-    temperature: forkOptions.temperature ?? parentConfig.temperature,
-    topP: parentConfig.topP,
-    reasoningLevel: forkOptions.reasoningLevel ?? reasoningLevel,
-    ...childPrompt,
-    sessionManager: new SessionManager(sessions.getStorage()),
-    tools,
-    onDoomLoop: parentConfig.onDoomLoop,
-    enforceDoomLoop: parentConfig.enforceDoomLoop,
-    doomLoopThreshold: parentConfig.doomLoopThreshold,
-    compaction: parentConfig.compaction,
-    contextWindow: parentConfig.contextWindow,
-    mcp: mcpManager,
-    middleware: resolveForkMiddleware(forkOptions, middlewareRunner)
-  };
-}
-
-// src/agent/mcp-bridge.ts
-async function ensureMcpTools(state) {
-  if (!state.manager) {
-    return { connected: false, cachedTools: void 0 };
-  }
-  if (state.connected && state.cachedTools) {
-    return {
-      connected: state.connected,
-      cachedTools: state.cachedTools
-    };
-  }
-  const statuses = await state.manager.connect();
-  let connectedCount = 0;
-  for (const [name, status] of statuses) {
-    if (status.status === "connected") {
-      connectedCount++;
-    } else if (status.status === "error") {
-      console.warn(`[mcp] Failed to connect to ${name}: ${status.error}`);
-    }
-  }
-  if (connectedCount === 0 && statuses.size > 0) {
-    console.warn("[mcp] No MCP servers connected successfully");
-  }
-  const cachedTools = await state.manager.getTools();
-  return {
-    connected: true,
-    cachedTools
-  };
-}
-async function closeMcpManager(manager) {
-  if (manager) {
-    await manager.close();
-  }
-  return {
-    connected: false,
-    cachedTools: void 0
-  };
-}
-
-// src/agent/session.ts
-async function ensureSessionLoaded(options) {
-  const { sessionId, sessions, loadedSessions, cwd } = options;
-  if (loadedSessions.has(sessionId) && sessions.getSessionId() === sessionId) {
-    return;
-  }
-  const exists = await sessions.sessionExists(sessionId);
-  if (exists) {
-    await sessions.load(sessionId);
-  } else {
-    await sessions.create({ id: sessionId, cwd });
-  }
-  loadedSessions.add(sessionId);
-}
-async function repairOrphanedToolCalls(sessions) {
-  const messages = sessions.getMessages();
-  const pendingCallIds = /* @__PURE__ */ new Map();
-  for (const message of messages) {
-    if (message.role === "assistant" && message.toolCalls) {
-      for (const toolCall of message.toolCalls) {
-        pendingCallIds.set(toolCall.toolCallId, { toolName: toolCall.toolName });
-      }
-    }
-    if (message.role === "tool" && message.toolCallId) {
-      pendingCallIds.delete(message.toolCallId);
-    }
-  }
-  for (const [toolCallId, { toolName }] of pendingCallIds) {
-    const toolMessage = {
-      id: crypto.randomUUID(),
-      role: "tool",
-      content: "Error: tool execution failed (result was not recorded)",
-      toolCallId,
-      toolName,
-      result: "Error: tool execution failed (result was not recorded)",
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    await sessions.addMessage(toolMessage);
-  }
-}
-async function createSubAgentRunSession(options) {
-  const sessionId = options.parentSessionId ? `${options.parentSessionId}:sub:${crypto.randomUUID().slice(0, 8)}` : `sub:${crypto.randomUUID().slice(0, 8)}`;
-  await options.sessions.create({
-    id: sessionId,
-    cwd: options.cwd,
-    title: options.title ?? "Sub-agent task",
-    parentSessionId: options.parentSessionId
-  });
-  options.loadedSessions.add(sessionId);
-  return sessionId;
-}
-
-// src/agent/intervention.ts
-var InterventionController = class {
-  /** Immediate interventions — applied at the next step boundary */
-  immediate = [];
-  /** Deferred messages — held until the turn completes */
-  deferred = [];
-  /**
-   * Callback fired when an intervention is wired into a step.
-   * Set by the Agent before starting a chat turn, cleared after.
-   */
-  onApplied;
-  // ---------------------------------------------------------------------------
-  // Immediate interventions (mid-turn redirect)
-  // ---------------------------------------------------------------------------
-  /**
-   * Inject a message at the next LLM step boundary.
-   *
-   * The message is appended as a user message to the conversation
-   * before the next LLM call in the current multi-step turn. The
-   * LLM will see it and can adjust its behavior accordingly.
-   *
-   * Safe to call from any async context while `chat()` is running.
-   * If called when no turn is active, the message will be picked up
-   * by the first step of the next `chat()` call.
-   *
-   * @param message - The user message to inject
-   * @returns Intervention ID for tracking
-   */
-  intervene(message) {
-    const id = crypto.randomUUID();
-    this.immediate.push(
-      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
-    );
-    return id;
-  }
-  /**
-   * Drain and return all pending immediate interventions.
-   * The internal queue is cleared atomically.
-   *
-   * @internal Called by the LLM stream's `prepareStep` hook
-   */
-  drainImmediate() {
-    if (this.immediate.length === 0) return [];
-    return this.immediate.splice(0);
-  }
-  /** Whether there are pending immediate interventions */
-  get hasPending() {
-    return this.immediate.length > 0;
-  }
-  /** Number of pending immediate interventions */
-  get pendingCount() {
-    return this.immediate.length;
+  return { systemPrompt: parentSystemPrompt };
+}
+function resolveForkMiddleware(options, middlewareRunner) {
+  if (options.middleware) {
+    return options.middleware;
   }
-  // ---------------------------------------------------------------------------
-  // Deferred messages (after-turn follow-ups)
-  // ---------------------------------------------------------------------------
-  /**
-   * Queue a message for after the current turn completes.
-   *
-   * Unlike `intervene()`, this does **not** inject mid-turn. The
-   * message is held and available via `drainDeferred()` after
-   * `chat()` finishes. The consumer decides whether to send it
-   * as a new turn.
-   *
-   * @param message - The message to queue
-   * @returns Intervention ID for tracking
-   */
-  queueNext(message) {
-    const id = crypto.randomUUID();
-    this.deferred.push(
-      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
-    );
-    return id;
+  if (options.additionalMiddleware) {
+    return [
+      ...middlewareRunner.getMiddleware(),
+      ...options.additionalMiddleware
+    ];
   }
-  /**
-   * Drain and return all deferred messages.
-   * The internal queue is cleared atomically.
-   */
-  drainDeferred() {
-    if (this.deferred.length === 0) return [];
-    return this.deferred.splice(0);
+  return [...middlewareRunner.getMiddleware()];
+}
+function createForkedAgentConfig(options) {
+  const {
+    forkOptions,
+    parentConfig,
+    parentTools,
+    reasoningLevel,
+    host,
+    ownsHost,
+    sessions,
+    mcpManager,
+    middlewareRunner,
+    promptBuilder
+  } = options;
+  const tools = forkOptions.tools ?? parentTools;
+  const childPrompt = resolveChildPromptConfig({
+    forkOptions,
+    promptBuilder,
+    parentPromptConfig: parentConfig.prompt,
+    parentSystemPrompt: parentConfig.systemPrompt
+  });
+  return {
+    model: forkOptions.model ?? parentConfig.model,
+    cwd: parentConfig.cwd,
+    ...ownsHost ? {} : { host },
+    maxOutputTokens: parentConfig.maxOutputTokens,
+    maxSteps: forkOptions.maxSteps ?? parentConfig.maxSteps,
+    temperature: forkOptions.temperature ?? parentConfig.temperature,
+    topP: parentConfig.topP,
+    reasoningLevel: forkOptions.reasoningLevel ?? reasoningLevel,
+    ...childPrompt,
+    sessionManager: new SessionManager(sessions.getStorage()),
+    tools,
+    onDoomLoop: parentConfig.onDoomLoop,
+    enforceDoomLoop: parentConfig.enforceDoomLoop,
+    doomLoopThreshold: parentConfig.doomLoopThreshold,
+    compaction: parentConfig.compaction,
+    contextWindow: parentConfig.contextWindow,
+    mcp: mcpManager,
+    middleware: resolveForkMiddleware(forkOptions, middlewareRunner)
+  };
+}
+
+// src/agent/mcp-bridge.ts
+async function ensureMcpTools(state) {
+  if (!state.manager) {
+    return { connected: false, cachedTools: void 0 };
   }
-  /** Whether there are deferred messages */
-  get hasDeferred() {
-    return this.deferred.length > 0;
+  if (state.connected && state.cachedTools) {
+    return {
+      connected: state.connected,
+      cachedTools: state.cachedTools
+    };
   }
-  /** Number of deferred messages */
-  get deferredCount() {
-    return this.deferred.length;
+  const statuses = await state.manager.connect();
+  let connectedCount = 0;
+  for (const [name, status] of statuses) {
+    if (status.status === "connected") {
+      connectedCount++;
+    } else if (status.status === "error") {
+      console.warn(`[mcp] Failed to connect to ${name}: ${status.error}`);
+    }
   }
-  // ---------------------------------------------------------------------------
-  // Housekeeping
-  // ---------------------------------------------------------------------------
-  /** Clear all queues (immediate + deferred) */
-  clear() {
-    this.immediate.length = 0;
-    this.deferred.length = 0;
+  if (connectedCount === 0 && statuses.size > 0) {
+    console.warn("[mcp] No MCP servers connected successfully");
   }
-  /** Reset the controller for a new turn (clears onApplied, keeps queues) */
-  resetCallbacks() {
-    this.onApplied = void 0;
+  const cachedTools = await state.manager.getTools();
+  return {
+    connected: true,
+    cachedTools
+  };
+}
+async function closeMcpManager(manager) {
+  if (manager) {
+    await manager.close();
   }
-};
+  return {
+    connected: false,
+    cachedTools: void 0
+  };
+}
 
 // src/agent/stream-provider.ts
 var DEFAULT_CUSTOM_STREAM_MODELS = [
@@ -808,7 +1005,7 @@ var DEFAULT_CUSTOM_STREAM_MODELS = [
   "computer-use-preview-2025-03-11"
 ];
 function needsCustomStreamProvider(model, customPatterns) {
-  const modelId = getModelId(model);
+  const modelId = extractModelId(model);
   if (!modelId || modelId === "[object Object]") return false;
   const patterns = customPatterns ?? DEFAULT_CUSTOM_STREAM_MODELS;
   return patterns.some((pattern) => modelId.includes(pattern));
@@ -824,7 +1021,7 @@ function autoDetectStreamProvider(model, tools, explicitProvider) {
   const enhancedTools = tools;
   const customPatterns = enhancedTools.__customStreamModels;
   if (needsCustomStreamProvider(model, customPatterns) && hasStreamProviderFactory(enhancedTools)) {
-    const modelId = getModelId(model);
+    const modelId = extractModelId(model);
     if (modelId) {
       const streamConfig = {
         apiKey: process.env.OPENAI_API_KEY,
@@ -900,24 +1097,39 @@ function createAgentState(config) {
 }
 function createAgentContextManager(config) {
   const compactionConfig = config.compaction ?? {};
-  const modelId = getModelId(config.model);
+  const modelId = extractModelId(config.model);
   const inferredWindow = inferContextWindow(modelId);
   const contextWindow = config.contextWindow ?? inferredWindow ?? DEFAULT_CONTEXT_LIMITS.contextWindow;
-  const reserveTokens = Math.min(
-    32e3,
-    Math.max(8e3, Math.round(contextWindow * 0.12))
-  );
   return new ContextManager({
     limits: {
       contextWindow,
-      reserveTokens,
-      protectedTokens: compactionConfig.protectedTokens ?? DEFAULT_CONTEXT_LIMITS.protectedTokens,
-      pruneMinimum: compactionConfig.pruneMinimum ?? DEFAULT_CONTEXT_LIMITS.pruneMinimum
+      ...resolveAgentContextLimits(contextWindow, compactionConfig)
     },
     model: compactionConfig.summaryModel ?? config.model,
     summaryPrompt: compactionConfig.summaryPrompt
   });
 }
+function resolveAgentContextLimits(contextWindow, compactionConfig = {}) {
+  const proportionalReserve = Math.round(contextWindow * 0.12);
+  const reserveTokens = contextWindow >= 64e3 ? Math.min(32e3, Math.max(8e3, proportionalReserve)) : Math.min(
+    Math.max(1024, Math.round(contextWindow * 0.25)),
+    Math.max(512, proportionalReserve)
+  );
+  const usableWindow = Math.max(512, contextWindow - reserveTokens);
+  const requestedProtected = compactionConfig.protectedTokens ?? DEFAULT_CONTEXT_LIMITS.protectedTokens;
+  const requestedPruneMinimum = compactionConfig.pruneMinimum ?? DEFAULT_CONTEXT_LIMITS.pruneMinimum;
+  return {
+    reserveTokens,
+    protectedTokens: Math.min(
+      requestedProtected,
+      Math.max(512, Math.round(usableWindow * 0.6))
+    ),
+    pruneMinimum: Math.min(
+      requestedPruneMinimum,
+      Math.max(256, Math.round(usableWindow * 0.5))
+    )
+  };
+}
 function createMiddlewareSetup(input, config) {
   let effectiveMiddleware = input.middleware;
   let telemetrySettings;
@@ -962,78 +1174,13 @@ function createAgentSetup(input) {
     ...promptBuilder ? { promptBuilder } : {},
     interventionCtrl: new InterventionController(),
     host: input.host ?? localHost(config.cwd),
+    ownsHost: input.host === void 0,
     middlewareRunner: middlewareSetup.middlewareRunner,
     ...middlewareSetup.telemetrySettings ? { telemetrySettings: middlewareSetup.telemetrySettings } : {},
     ...middlewareSetup.tracingShutdown ? { tracingShutdown: middlewareSetup.tracingShutdown } : {}
   };
 }
 
-// src/agent/runtime-config.ts
-function createAgentToolRecord(tools) {
-  const toolRecord = {};
-  for (const [id, tool] of tools) {
-    toolRecord[id] = tool;
-  }
-  return toolRecord;
-}
-function getAgentContextStats(contextManager, messages) {
-  return contextManager.getStats(messages);
-}
-async function compactAgentContext(contextManager, messages) {
-  const result = await contextManager.prune(messages);
-  return {
-    removedCount: result.removedCount,
-    tokensRemoved: result.tokensRemoved,
-    summarized: result.summarized,
-    summary: result.summary
-  };
-}
-async function buildAgentSystemPrompts(options) {
-  const {
-    config,
-    toolIds,
-    sessionId,
-    override,
-    promptBuilder,
-    middlewareRunner
-  } = options;
-  if (promptBuilder) {
-    const composedPrompt = await promptBuilder.build(
-      {
-        cwd: config.cwd,
-        model: config.model,
-        toolNames: toolIds,
-        ...override ? { override } : {},
-        sessionId
-      },
-      middlewareRunner
-    );
-    return [composedPrompt];
-  }
-  const prompts = [config.systemPrompt];
-  if (override) {
-    prompts.push(override);
-  }
-  return prompts;
-}
-function createAgentTurnRuntimeConfig(options) {
-  const { config, telemetrySettings } = options;
-  return {
-    model: config.model,
-    cwd: config.cwd,
-    ...config.temperature !== void 0 ? { temperature: config.temperature } : {},
-    ...config.topP !== void 0 ? { topP: config.topP } : {},
-    ...config.maxOutputTokens !== void 0 ? { maxOutputTokens: config.maxOutputTokens } : {},
-    maxSteps: config.maxSteps,
-    ...config.doomLoopThreshold !== void 0 ? { doomLoopThreshold: config.doomLoopThreshold } : {},
-    ...config.enforceDoomLoop !== void 0 ? { enforceDoomLoop: config.enforceDoomLoop } : {},
-    ...config.onDoomLoop ? { onDoomLoop: config.onDoomLoop } : {},
-    ...config.contextWindow !== void 0 ? { contextWindow: config.contextWindow } : {},
-    ...config.streamProvider ? { streamProvider: config.streamProvider } : {},
-    ...telemetrySettings ? { telemetry: telemetrySettings } : {}
-  };
-}
-
 // src/agent/instance.ts
 function createAgent(config) {
   return new Agent(config);
@@ -1042,7 +1189,6 @@ var Agent = class _Agent {
   config;
   tools;
   sessions;
-  loadedSessions = /* @__PURE__ */ new Set();
   state;
   /** Context manager for overflow detection and compaction */
   contextManager;
@@ -1066,6 +1212,8 @@ var Agent = class _Agent {
   interventionCtrl;
   /** Execution environment for tool operations */
   host;
+  /** Whether the agent owns the host and can safely recreate it on cwd changes */
+  ownsHost;
   /** Middleware runner for lifecycle hooks */
   middlewareRunner;
   /** AI SDK telemetry settings (auto-created from `tracing` config) */
@@ -1074,6 +1222,12 @@ var Agent = class _Agent {
   tracingShutdown;
   /** Multi-consumer event dispatch */
   _signal;
+  /** Number of active turns across all sessions */
+  activeTurnCount = 0;
+  /** Active turn intervention controllers, keyed by turn id */
+  activeTurns = /* @__PURE__ */ new Map();
+  /** Per-session turn queue to prevent concurrent writes to the same history */
+  sessionLocks = /* @__PURE__ */ new Map();
   constructor(config) {
     const setup = createAgentSetup(config);
     this.config = setup.config;
@@ -1086,6 +1240,7 @@ var Agent = class _Agent {
     this.promptBuilder = setup.promptBuilder;
     this.interventionCtrl = setup.interventionCtrl;
     this.host = setup.host;
+    this.ownsHost = setup.ownsHost;
     this.middlewareRunner = setup.middlewareRunner;
     this.telemetrySettings = setup.telemetrySettings;
     this.tracingShutdown = setup.tracingShutdown;
@@ -1119,7 +1274,7 @@ var Agent = class _Agent {
   }
   /** Is currently streaming */
   get isStreaming() {
-    return this.state.isStreaming;
+    return this.activeTurnCount > 0;
   }
   /** Current reasoning level */
   get reasoningLevel() {
@@ -1162,6 +1317,74 @@ var Agent = class _Agent {
       }
     }
   }
+  resetPromptScopedTools() {
+    this.tools.delete("skill");
+    this.tools.delete("skill_resource");
+    this.skillToolsResolved = false;
+  }
+  createSessionManager() {
+    return new SessionManager(this.sessions.getStorage());
+  }
+  async acquireSessionLock(sessionId) {
+    const previous = this.sessionLocks.get(sessionId) ?? Promise.resolve();
+    let releaseLock;
+    const current = new Promise((resolve) => {
+      releaseLock = resolve;
+    });
+    const chain = previous.catch(() => void 0).then(() => current);
+    this.sessionLocks.set(sessionId, chain);
+    await previous.catch(() => void 0);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      releaseLock();
+      if (this.sessionLocks.get(sessionId) === chain) {
+        this.sessionLocks.delete(sessionId);
+      }
+    };
+  }
+  getActiveInterventionController() {
+    const active = Array.from(this.activeTurns.values());
+    if (active.length === 0) {
+      return void 0;
+    }
+    if (active.length > 1) {
+      throw new Error(
+        "Interventions are ambiguous while multiple agent turns are active. Use separate Agent instances or wait for one turn to finish."
+      );
+    }
+    return active[0].interventionCtrl;
+  }
+  getInterventionControllerForTurn() {
+    const activeController = this.getActiveInterventionController();
+    return activeController ?? this.interventionCtrl;
+  }
+  createTurnInterventionController() {
+    return this.activeTurns.size === 0 ? this.interventionCtrl : new InterventionController();
+  }
+  releaseTurnInterventions(controller) {
+    if (controller === this.interventionCtrl) {
+      controller.resetCallbacks();
+      return;
+    }
+    this.interventionCtrl.adoptImmediate(controller.drainImmediate());
+    this.interventionCtrl.adoptDeferred(controller.drainDeferred());
+    controller.resetCallbacks();
+  }
+  syncStreamingState(active) {
+    this.activeTurnCount = Math.max(
+      0,
+      this.activeTurnCount + (active ? 1 : -1)
+    );
+    this.state.isStreaming = this.activeTurnCount > 0;
+  }
+  async syncSessionView(sessionId) {
+    if (!await this.sessions.sessionExists(sessionId)) {
+      return;
+    }
+    await this.sessions.load(sessionId);
+  }
   /**
    * Ensure MCP is connected and return tools
    * Lazy initialization - only connects on first use
@@ -1185,8 +1408,8 @@ var Agent = class _Agent {
    * `MissingToolResultsError`. This method detects orphaned tool-call IDs
    * and adds placeholder `tool` messages so the history is valid again.
    */
-  async repairOrphanedToolCalls() {
-    await repairOrphanedToolCalls(this.sessions);
+  async repairOrphanedToolCalls(sessions) {
+    await repairOrphanedToolCalls(sessions);
   }
   /**
    * Convert internal {@link Message} array to Vercel AI SDK {@link ModelMessage} format.
@@ -1212,52 +1435,75 @@ var Agent = class _Agent {
    * @yields {AgentEvent} Events as they occur during processing
    */
   async *chat(sessionId, message, options) {
-    await this.ensureSession(sessionId);
-    await this.ensureSkillTools();
-    const abort = options?.abort ?? new AbortController().signal;
+    const releaseSessionLock = await this.acquireSessionLock(sessionId);
+    const sessions = this.createSessionManager();
     const turnId = `${sessionId}-turn-${++this.turnCounter}`;
-    this.turnTracker.startTurn(turnId);
-    await this.repairOrphanedToolCalls();
-    const mcpTools = await this.ensureMCPConnected();
-    const loop = runChatLoop({
-      sessionId,
-      message,
-      abort,
-      systemOverride: options?.system,
-      sessions: this.sessions,
-      tools: createAgentToolRecord(this.tools),
-      config: this.config,
-      turnTracker: this.turnTracker,
-      interventionCtrl: this.interventionCtrl,
-      middlewareRunner: this.middlewareRunner,
-      contextManager: this.contextManager,
-      rememberedDoomLoopTools: this.rememberedDoomLoopTools,
-      reasoningLevel: this.state.reasoningLevel,
-      promptBuilder: this.promptBuilder,
-      host: this.host,
-      mcpTools,
-      telemetrySettings: this.telemetrySettings,
-      toModelMessages: this.toModelMessages.bind(this),
-      setIsStreaming: (v) => {
-        this.state.isStreaming = v;
+    let turnTracker;
+    let interventionCtrl = this.interventionCtrl;
+    let streamingStateActive = false;
+    let turnRegistered = false;
+    try {
+      await this.ensureSkillTools();
+      const abort = options?.abort ?? new AbortController().signal;
+      turnTracker = createTurnTracker({ cwd: this.config.cwd });
+      interventionCtrl = this.createTurnInterventionController();
+      this.activeTurns.set(turnId, { sessionId, interventionCtrl });
+      turnRegistered = true;
+      await ensureSessionLoaded({
+        sessionId,
+        sessions,
+        cwd: this.config.cwd
+      });
+      turnTracker.startTurn(turnId);
+      await this.repairOrphanedToolCalls(sessions);
+      const mcpTools = await this.ensureMCPConnected();
+      const loop = runChatLoop({
+        sessionId,
+        message,
+        abort,
+        systemOverride: options?.system,
+        sessions,
+        tools: createAgentToolRecord(this.tools),
+        config: this.config,
+        turnTracker,
+        interventionCtrl,
+        middlewareRunner: this.middlewareRunner,
+        contextManager: this.contextManager,
+        rememberedDoomLoopTools: this.rememberedDoomLoopTools,
+        reasoningLevel: this.state.reasoningLevel,
+        promptBuilder: this.promptBuilder,
+        host: this.host,
+        mcpTools,
+        telemetrySettings: this.telemetrySettings,
+        toModelMessages: this.toModelMessages.bind(this),
+        setIsStreaming: (value) => {
+          if (value === streamingStateActive) return;
+          streamingStateActive = value;
+          this.syncStreamingState(value);
+        }
+      });
+      for await (const event of loop) {
+        this._signal.emit(event);
+        yield event;
+      }
+    } finally {
+      try {
+        if (streamingStateActive) {
+          this.syncStreamingState(false);
+        }
+        if (turnRegistered) {
+          this.activeTurns.delete(turnId);
+        }
+        this.releaseTurnInterventions(interventionCtrl);
+        if (turnRegistered && turnTracker) {
+          this.turnTracker = turnTracker;
+        }
+        await this.syncSessionView(sessionId);
+      } finally {
+        releaseSessionLock();
       }
-    });
-    for await (const event of loop) {
-      this._signal.emit(event);
-      yield event;
     }
   }
-  /**
-   * Ensure a session is loaded or created
-   */
-  async ensureSession(sessionId) {
-    await ensureSessionLoaded({
-      sessionId,
-      sessions: this.sessions,
-      loadedSessions: this.loadedSessions,
-      cwd: this.config.cwd
-    });
-  }
   /**
    * Send a message and wait for the complete response (non-streaming).
    *
@@ -1332,7 +1578,6 @@ var Agent = class _Agent {
   }
   /** Delete a session */
   async deleteSession(sessionId) {
-    this.loadedSessions.delete(sessionId);
     return this.sessions.deleteSession(sessionId);
   }
   /** List all sessions */
@@ -1382,10 +1627,10 @@ var Agent = class _Agent {
    * @returns Pruning result with details about what was removed/summarized
    */
   async compactContext() {
-    return await compactAgentContext(
-      this.contextManager,
-      this.sessions.getMessages()
-    );
+    return await compactAgentContext({
+      contextManager: this.contextManager,
+      sessions: this.sessions
+    });
   }
   /**
    * Clear remembered doom loop tools.
@@ -1415,6 +1660,8 @@ var Agent = class _Agent {
    *
    * If called when no turn is active, the message will be picked up
    * by the first step of the next `chat()` call.
+   * If multiple turns are active concurrently, this throws because the
+   * target turn would be ambiguous.
    *
    * @param message - The user message to inject mid-turn
    * @returns Intervention ID for tracking
@@ -1436,7 +1683,7 @@ var Agent = class _Agent {
    * ```
    */
   intervene(message) {
-    return this.interventionCtrl.intervene(message);
+    return this.getInterventionControllerForTurn().intervene(message);
   }
   /**
    * Queue a message for after the current turn completes.
@@ -1446,6 +1693,9 @@ var Agent = class _Agent {
    * `chat()` finishes. The consumer decides whether to send it as a
    * new turn.
    *
+   * If multiple turns are active concurrently, this throws because the
+   * target turn would be ambiguous.
+   *
    * @param message - The message to queue
    * @returns Intervention ID for tracking
    *
@@ -1468,15 +1718,15 @@ var Agent = class _Agent {
    * ```
    */
   queueNext(message) {
-    return this.interventionCtrl.queueNext(message);
+    return this.getInterventionControllerForTurn().queueNext(message);
   }
   /** Whether there are deferred messages queued for after the turn */
   hasQueuedNext() {
-    return this.interventionCtrl.hasDeferred;
+    return this.getInterventionControllerForTurn().hasDeferred;
   }
   /** Drain and return all deferred messages (clears the queue) */
   drainQueuedNext() {
-    return this.interventionCtrl.drainDeferred();
+    return this.getInterventionControllerForTurn().drainDeferred();
   }
   /**
    * Get the raw intervention controller for advanced use cases.
@@ -1488,7 +1738,7 @@ var Agent = class _Agent {
    * @internal
    */
   getInterventionController() {
-    return this.interventionCtrl;
+    return this.getInterventionControllerForTurn();
   }
   // ============================================================================
   // Turn Tracking
@@ -1565,26 +1815,37 @@ var Agent = class _Agent {
     this.config.systemPrompt = prompt;
     this.state.systemPrompt = prompt;
     this.promptBuilder = void 0;
+    this.resetPromptScopedTools();
   }
   /** Update working directory */
   setCwd(cwd) {
     this.config.cwd = cwd;
     this.state.cwd = cwd;
+    this.turnTracker = createTurnTracker({ cwd });
+    if (this.ownsHost) {
+      this.host = localHost(cwd);
+    }
+    this.resetPromptScopedTools();
     this.promptBuilder?.clearCache();
   }
   /** Update model */
   setModel(model) {
     this.config.model = model;
     this.state.model = model;
+    if (this.config.compaction?.summaryModel === void 0) {
+      this.contextManager.setModel(model);
+    }
     if (this.config.contextWindow === void 0) {
-      const modelId = getModelId(model);
+      const modelId = extractModelId(model);
       const inferred = inferContextWindow(modelId);
       if (inferred) {
-        const reserveTokens = Math.min(
-          32e3,
-          Math.max(8e3, Math.round(inferred * 0.12))
-        );
-        this.contextManager.setLimits({ contextWindow: inferred, reserveTokens });
+        this.contextManager.setLimits({
+          contextWindow: inferred,
+          ...resolveAgentContextLimits(
+            inferred,
+            this.config.compaction
+          )
+        });
       }
     }
   }
@@ -1624,6 +1885,7 @@ var Agent = class _Agent {
    * runtimes can start durable turns without duplicating prompt assembly.
    */
   async buildSystemPrompts(sessionId, override) {
+    await this.ensureSkillTools();
     return await buildAgentSystemPrompts({
       config: this.config,
       toolIds: Array.from(this.tools.keys()),
@@ -1699,6 +1961,7 @@ var Agent = class _Agent {
         parentTools: Array.from(this.tools.values()),
         reasoningLevel: this.state.reasoningLevel,
         host: this.host,
+        ownsHost: this.ownsHost,
         sessions: this.sessions,
         mcpManager: this.mcpManager,
         middlewareRunner: this.middlewareRunner,
@@ -1750,9 +2013,9 @@ var Agent = class _Agent {
    * ```
    */
   async run(options) {
+    const sessions = this.createSessionManager();
     const sessionId = await createSubAgentRunSession({
-      sessions: this.sessions,
-      loadedSessions: this.loadedSessions,
+      sessions,
       cwd: this.config.cwd,
       parentSessionId: options.parentSessionId,
       title: options.title
@@ -1821,6 +2084,7 @@ async function runConcurrent(tasks, options) {
   let currentIndex = 0;
   async function runNext() {
     while (currentIndex < tasks.length) {
+      if (options?.abort?.aborted) break;
       const index = currentIndex++;
       const task = tasks[index];
       results[index] = await task.agent.run({
@@ -1871,12 +2135,14 @@ export {
   InterventionController,
   LLM,
   LLMError,
+  LayeredSettings,
   LocalSignal,
   MAX_BYTES,
   MAX_LINES,
   MemoryStorage,
   MiddlewareRunner,
   ModelCapabilityResolver,
+  NullSettings,
   OUTPUT_TOKEN_MAX,
   PRIORITY_BASE,
   PRIORITY_CUSTOM,
@@ -1886,6 +2152,8 @@ export {
   PRIORITY_SKILLS,
   PRUNE_PROTECTED_TOOLS,
   PatternCapabilitySource,
+  PluginEventBus,
+  PluginRegistry,
   Presets,
   PromptBuilder,
   RemoteCapabilityFetcher,
@@ -1896,12 +2164,14 @@ export {
   SessionManager,
   SkillRegistry,
   SourcePriority,
+  StaticSettings,
   SubAgentTracker,
   TRUNCATE_DIR,
   TRUNCATE_GLOB,
   Tool,
   ToolRegistry,
   TurnChangeTracker,
+  ValidatedSettings,
   advanceAgentTurnState,
   applyAgentWorkflowCommitResult,
   applyAgentWorkflowModelStepResult,
@@ -1960,11 +2230,14 @@ export {
   currentScope,
   defaultAgentTaskCheckpointStrategy,
   defaultRegistry,
+  definePlugin,
   defineServer,
   defineTool,
   deserializeMessage,
   detectModelFamily,
+  discoverAgentProfiles,
   discoverInstructions,
+  discoverPlugins,
   discoverSkills,
   dockerHost,
   emptySkillRegistry,
@@ -1997,6 +2270,8 @@ export {
   getLeafId,
   getModelId,
   getNetworkStatus,
+  getPluginLoader,
+  getProjectAgentsDir,
   getProjectId,
   getProjectSessionsDir,
   getProviderCompatibility,
@@ -2008,16 +2283,20 @@ export {
   getSessionsDir,
   getTemplate,
   getToolRisk,
+  getUserAgentsDir,
   hasStreamProviderFactory,
   httpServer,
   inferContextWindow,
   inferProvider,
   inferResourceType,
   isContextOverflowing,
+  isDefinedPlugin,
+  isMarkdownProfile,
   isRetryable,
   isRetryableCategory,
   likelySupportsReasoning,
   loadGlobalInstructions,
+  loadPluginModule,
   loadResourceContent,
   loadSkillContent,
   loadSkillMetadata,
@@ -2026,9 +2305,12 @@ export {
   needsCustomStreamProvider,
   normalizeToolReplayPolicy,
   otelMiddleware,
+  parseAgentFrontmatter,
   parseFrontmatter,
   parseJSONL,
+  parseMarkdownAgent,
   parseRetryDelay,
+  parseToolSpec,
   plan,
   planNextAgentWorkflowOperation,
   prepareModelStep,
@@ -2039,6 +2321,9 @@ export {
   pruneToolResults,
   quick,
   recordAgentWorkflowReplayDecision,
+  resetFrameworkAliases,
+  resetPluginLoader,
+  resolveFrameworkAliases,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,
   restoreScope,
@@ -2064,6 +2349,7 @@ export {
   summarizeEnvironment,
   supportsReasoning,
   supportsReasoningSync,
+  toAgentProfile,
   toJSONL,
   toJSONLBatch,
   truncateOutput,