@cuylabs/agent-core 4.8.1 → 4.10.0

package/dist/index.js

@@ -1,3 +1,8 @@
+import {
+  createSkillResourceTool,
+  createSkillTool,
+  createSkillTools
+} from "./chunk-ASXF5AC6.js";
 import {
   DEFAULT_SUBAGENT_CONCURRENCY,
   DEFAULT_SUBAGENT_DEPTH,
@@ -34,7 +39,7 @@ import {
   parseSubAgentRoleFrontmatter,
   parseSubAgentToolSpec,
   toSubAgentRole
-} from "./chunk-BJC46FIF.js";
+} from "./chunk-V4YQ6MBK.js";
 import {
   InMemoryMailboxStore,
   InMemoryTaskBoardStore,
@@ -53,18 +58,32 @@ import {
   formatCoordinatorTaskNotifications,
   formatCoordinatorWorkerReports,
   teamPermissionPolicy
-} from "./chunk-QJV5XPPS.js";
+} from "./chunk-UEEHZ4QH.js";
 import {
   ToolRegistry,
   createToolSearchTool,
   defaultRegistry
-} from "./chunk-KYLPMBHD.js";
-import "./chunk-O2WCYSXQ.js";
+} from "./chunk-336EDIBL.js";
 import {
   ToolHostRegistry,
   defaultToolHostRegistry,
   localHost
 } from "./chunk-X4VN4GIJ.js";
+import {
+  createMemoryMiddleware,
+  formatMemoryContextFragment,
+  normalizeMemoryRecords,
+  resolveAgentMemoryConfig,
+  resolveAgentMemoryTurnConfig
+} from "./chunk-EEAGM5MS.js";
+import {
+  MiddlewareRunner,
+  approvalMiddleware,
+  createTelemetryConfig,
+  isApprovalMiddleware,
+  otelMiddleware,
+  promptCacheMiddleware
+} from "./chunk-TU5KDFWI.js";
 import {
   LayeredSettings,
   NullSettings,
@@ -101,6 +120,7 @@ import {
   DEFAULT_INSTRUCTION_PATTERNS,
   DEFAULT_MAX_DEPTH,
   DEFAULT_MAX_FILE_SIZE,
+  DEFAULT_SYSTEM_PROMPT,
   PRIORITY_BASE,
   PRIORITY_CUSTOM,
   PRIORITY_ENVIRONMENT,
@@ -118,13 +138,7 @@ import {
   getTemplate,
   loadGlobalInstructions,
   summarizeEnvironment
-} from "./chunk-BGG2HVIR.js";
-import "./chunk-VOUEJSW6.js";
-import {
-  createSkillResourceTool,
-  createSkillTool,
-  createSkillTools
-} from "./chunk-CSR75JVC.js";
+} from "./chunk-V4MIDL5B.js";
 import {
   DEFAULT_EXTERNAL_DIRS,
   DEFAULT_MAX_SCAN_DEPTH,
@@ -140,6 +154,10 @@ import {
   loadSkillMetadata,
   parseFrontmatter
 } from "./chunk-I7EJGKUP.js";
+import "./chunk-VOUEJSW6.js";
+import {
+  assembleModelContext
+} from "./chunk-IQA64CAO.js";
 import {
   createCompositeDispatchTaskExecutor,
   createDispatchExternalTaskControl,
@@ -161,17 +179,7 @@ import {
   ensureSessionLoaded,
   getVisibleSessionMessages,
   repairOrphanedToolCalls
-} from "./chunk-HSUPTXNV.js";
-import {
-  sleep
-} from "./chunk-SZ2XBPTW.js";
-import {
-  MAX_BYTES,
-  MAX_LINES,
-  Tool,
-  normalizeToolReplayPolicy,
-  truncateOutput
-} from "./chunk-Q742PSH3.js";
+} from "./chunk-EBVSPHXA.js";
 import {
   FileStorage,
   LocalSessionTurnLock,
@@ -199,54 +207,117 @@ import {
   serializeMessage,
   toJSONL,
   toJSONLBatch
-} from "./chunk-H3GRHFFG.js";
+} from "./chunk-VMGZKIFT.js";
+import {
+  sleep
+} from "./chunk-SZ2XBPTW.js";
+import {
+  MAX_BYTES,
+  MAX_LINES,
+  Tool,
+  normalizeToolReplayPolicy,
+  truncateOutput
+} from "./chunk-MJML3A2F.js";
+import "./chunk-3NBTQHVV.js";
 import {
   createEventBus
-} from "./chunk-2TTOLHBT.js";
+} from "./chunk-CFBSQLP5.js";
+import {
+  LocalSignal
+} from "./chunk-UG5PVNZV.js";
+import {
+  createAgentTaskRunner,
+  defaultAgentTaskCheckpointStrategy
+} from "./chunk-JFH6HBUG.js";
 import {
   AgentTurnEngine,
-  ContextManager,
   ContextOverflowError,
-  DEFAULT_CONTEXT_LIMITS,
   DoomLoopError,
-  PRUNE_PROTECTED_TOOLS,
-  accumulateUsage,
-  advanceAgentTurnState,
+  commitOutput,
+  commitStep,
+  createAgentTurnEngine,
+  createAgentTurnStepCommitBatch,
+  prepareModelStep,
+  processStepStream,
+  runModelStep,
+  runToolBatch
+} from "./chunk-LX4AHGI3.js";
+import {
   applyAgentWorkflowCommitResult,
+  applyAgentWorkflowContextCompactionResult,
   applyAgentWorkflowModelStepResult,
   applyAgentWorkflowToolBatchResult,
   applyAgentWorkflowToolCallResult,
   applyWorkflowInterventions,
   cloneAgentWorkflowTurnState,
-  commitOutput,
-  commitStep,
-  createAgentTaskRunner,
-  createAgentTurnEngine,
-  createAgentTurnState,
-  createAgentTurnStepCommitBatch,
   createAgentWorkflowTurnState,
-  defaultAgentTaskCheckpointStrategy,
   drainWorkflowInterventions,
-  estimateConversationTokens,
-  estimateMessageTokens,
-  estimateTokens,
-  failAgentTurnState,
   failAgentWorkflowTurnState,
-  findCutPoint,
-  getUsableTokenLimit,
   planNextAgentWorkflowOperation,
-  prepareModelStep,
-  processStepStream,
   queueWorkflowFollowUps,
   recordAgentWorkflowReplayDecision,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,
-  runModelStep,
-  runToolBatch,
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages
-} from "./chunk-V6ETEYST.js";
+} from "./chunk-MJRZ2ZRI.js";
+import {
+  AgentTurnStateConflictError,
+  accumulateUsage,
+  advanceAgentTurnState,
+  createAgentTurnState,
+  failAgentTurnState,
+  getCurrentAgentTurnStepRecord,
+  mergeAgentTurnStateProgress
+} from "./chunk-E66PKKDL.js";
+import {
+  ContextSummaryModelRequiredError,
+  ContextWindowManager,
+  DEFAULT_COMPACTION_EFFECTIVE_MIN_SAVINGS_RATIO,
+  DEFAULT_CONTEXT_LIMITS,
+  DEFAULT_SUMMARY_MAX_INPUT_TOKENS,
+  DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS,
+  PRUNE_PROTECTED_TOOLS,
+  canGenerateCompactionSummary,
+  createCompactionEffectiveness,
+  createCompactionSummaryContent,
+  decideContextCompaction,
+  extractCompactionSummaryText,
+  generateSplitTurnSummary,
+  generateSummary,
+  getUsableTokenLimit,
+  isContextOverflowing,
+  planCompactionCut,
+  pruneContext,
+  pruneToolContext,
+  pruneToolContextWithReport,
+  redactSummaryText,
+  resolveContextSummaryPolicy,
+  resolveSummaryOutputTokens,
+  serializeMessagesForSummary,
+  shouldFallbackOnSummaryFailure,
+  shouldPruneContext
+} from "./chunk-NMJNN6LS.js";
+import {
+  AGENT_CONTEXT_FRAGMENT_CLOSE,
+  AGENT_CONTEXT_FRAGMENT_OPEN,
+  AGENT_CONTEXT_FRAGMENT_TAG,
+  applyAgentContextFragments,
+  applyAgentContextFragmentsWithReport,
+  createAgentContextFragmentMessage,
+  estimateConversationTokens,
+  estimateMessageTokens,
+  estimateTokens,
+  getAgentContextFragmentMetadata,
+  isAgentContextFragmentMessage,
+  isRenderedAgentContextFragment,
+  normalizeAgentContextFragment,
+  parseRenderedAgentContextFragment,
+  renderAgentContextFragment
+} from "./chunk-AAGKWUXR.js";
 import {
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  DEFAULT_MAX_STEPS,
   DEFAULT_RETRY_CONFIG,
   Inference,
   buildModelCallContext,
@@ -260,17 +331,7 @@ import {
   streamOnce,
   streamStep,
   withRetry
-} from "./chunk-NS7D7JJU.js";
-import {
-  currentScope,
-  executeAgentToolCall,
-  extractFilePathsFromArgs,
-  restoreScope,
-  shouldCaptureBaseline,
-  snapshotScope,
-  streamWithinScope,
-  withinScope
-} from "./chunk-MWPU2EVV.js";
+} from "./chunk-K453AFTL.js";
 import {
   LLMError,
   getErrorCategory,
@@ -279,6 +340,21 @@ import {
   isRetryableCategory,
   parseRetryDelay
 } from "./chunk-STDJYXYK.js";
+import {
+  executeAgentToolCall,
+  extractFilePathsFromArgs,
+  shouldCaptureBaseline
+} from "./chunk-JUIL2NJC.js";
+import {
+  currentScope,
+  restoreScope,
+  snapshotScope,
+  streamWithinScope,
+  withinScope
+} from "./chunk-AHDCR7SX.js";
+import {
+  isBlockedModelCall
+} from "./chunk-W6LWIMIX.js";
 import {
   CacheCapabilitySource,
   CapabilityCache,
@@ -309,34 +385,7 @@ import {
   shouldIncludeReasoningSummary,
   supportsReasoning,
   supportsReasoningSync
-} from "./chunk-GJFP5L2V.js";
-import "./chunk-SPBFQXOT.js";
-import {
-  ClientCredentialsProvider,
-  createDiagnosticFetch,
-  createMCPManager,
-  httpServer,
-  serviceAccountServer,
-  sseServer,
-  stdioServer
-} from "./chunk-UMIVJDEJ.js";
-import {
-  MiddlewareRunner,
-  approvalMiddleware,
-  createTelemetryConfig,
-  isApprovalMiddleware,
-  otelMiddleware,
-  promptCacheMiddleware
-} from "./chunk-GEBFHREI.js";
-import {
-  DEFAULT_AGENT_NAME,
-  DEFAULT_MAX_STEPS,
-  DEFAULT_MAX_TOKENS,
-  DEFAULT_SYSTEM_PROMPT,
-  isBlockedModelCall,
-  resolveAgentDefaults,
-  sandboxDefaultsProvider
-} from "./chunk-CJI7PVS2.js";
+} from "./chunk-CNM6OROH.js";
 import {
   DEFAULT_RESOLVER_OPTIONS,
   PatternCapabilitySource,
@@ -388,6 +437,16 @@ import {
   requiresToolHost,
   resolveCapability
 } from "./chunk-FII65CN7.js";
+import "./chunk-SPBFQXOT.js";
+import {
+  ClientCredentialsProvider,
+  createDiagnosticFetch,
+  createMCPManager,
+  httpServer,
+  serviceAccountServer,
+  sseServer,
+  stdioServer
+} from "./chunk-SAWRDGBE.js";
 import {
   createConsoleLogger,
   createFileLogger,
@@ -878,1313 +937,2301 @@ var InterventionController = class {
   }
 };
 
-// src/agent/runtime-config.ts
-function createAgentToolRecord(tools) {
-  const toolRecord = {};
-  for (const [id, tool] of tools) {
-    toolRecord[id] = tool;
+// src/agent/stream-provider.ts
+var DEFAULT_CUSTOM_STREAM_MODELS = [
+  "computer-use-preview",
+  "computer-use-preview-2025-03-11"
+];
+function needsCustomStreamProvider(model, customPatterns) {
+  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));
+}
+function hasStreamProviderFactory(tools) {
+  return Array.isArray(tools) && typeof tools.__streamProviderFactory === "function";
+}
+function autoDetectStreamProvider(model, tools, explicitProvider) {
+  if (explicitProvider) {
+    return explicitProvider;
   }
-  return toolRecord;
+  if (!tools) return void 0;
+  const enhancedTools = tools;
+  const customPatterns = enhancedTools.__customStreamModels;
+  if (needsCustomStreamProvider(model, customPatterns) && hasStreamProviderFactory(enhancedTools)) {
+    const modelId = extractModelId(model);
+    if (modelId) {
+      const streamConfig = {
+        apiKey: process.env.OPENAI_API_KEY,
+        display: { width: 1024, height: 768 },
+        environment: "linux",
+        debug: false
+      };
+      return enhancedTools.__streamProviderFactory(modelId, streamConfig);
+    }
+  }
+  return void 0;
 }
-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.";
+// src/agent/defaults.ts
+var DEFAULT_AGENT_NAME = "agent";
+var DEFAULT_MAX_TOKENS = DEFAULT_MAX_OUTPUT_TOKENS;
+function resolveAgentDefaults(context, providers) {
+  let merged = {
+    systemPrompt: DEFAULT_SYSTEM_PROMPT,
+    maxSteps: DEFAULT_MAX_STEPS,
+    maxOutputTokens: DEFAULT_MAX_TOKENS
+  };
+  if (providers) {
+    for (const provider of providers) {
+      const overrides = provider(context);
+      if (overrides) {
+        merged = {
+          systemPrompt: overrides.systemPrompt ?? merged.systemPrompt,
+          maxSteps: overrides.maxSteps ?? merged.maxSteps,
+          maxOutputTokens: overrides.maxOutputTokens ?? merged.maxOutputTokens
+        };
+      }
+    }
+  }
+  return merged;
 }
-async function compactAgentContext(options) {
-  const { contextManager, sessions, logger } = options;
-  const log = logger ?? silentLogger;
-  const messages = getVisibleSessionMessages(sessions);
-  if (!contextManager.shouldPrune(messages)) {
-    return {
-      removedCount: 0,
-      tokensRemoved: 0,
-      summarized: false,
-      summary: void 0
-    };
+function sandboxDefaultsProvider(context) {
+  const sandbox = context.sandbox;
+  if (!sandbox) {
+    return 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 (pruneError) {
-    log.warn("Context compaction LLM summarisation failed, using fallback", {
-      error: pruneError instanceof Error ? pruneError.message : String(pruneError)
-    });
+  const managed = sandbox.metadata?.managed === true;
+  if (managed) {
+    return { maxSteps: 100 };
   }
-  if (removedCount === 0) {
-    removedCount = findCutPoint(
-      messages,
-      contextManager.getLimits().protectedTokens
-    );
+  return void 0;
+}
+
+// src/agent/setup/config.ts
+function createAgentPromptBuilder(config) {
+  if (config.prompt !== void 0) {
+    return createPromptBuilder(config.prompt);
   }
-  if (removedCount === 0) {
-    return {
-      removedCount: 0,
-      tokensRemoved: 0,
-      summarized: false,
-      summary: void 0
-    };
+  if (config.systemPrompt === void 0) {
+    return createPromptBuilder();
   }
-  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
+  return void 0;
+}
+function createEffectiveAgentConfig(config) {
+  const effectiveStreamProvider = autoDetectStreamProvider(
+    config.model,
+    config.tools,
+    config.streamProvider
+  );
+  const resolvedCwd = config.cwd ?? config.sandbox?.metadata?.workingDirectory ?? process.cwd();
+  const defaultsContext = {
+    sandbox: config.sandbox,
+    cwd: resolvedCwd,
+    modelId: extractModelId(config.model)
+  };
+  const providers = [
+    sandboxDefaultsProvider,
+    ...config.defaultsProviders ?? []
   ];
-  const tokensAfter = estimateConversationTokens(persistedMessages);
-  await sessions.replaceWithCompaction({
-    summary: summaryText,
-    messages: keptMessages,
-    tokensBefore,
-    tokensAfter
-  });
+  const defaults = resolveAgentDefaults(defaultsContext, providers);
   return {
-    removedCount,
-    tokensRemoved: Math.max(0, tokensBefore - tokensAfter),
-    summarized,
-    summary: summaryText
+    ...config,
+    systemPrompt: config.systemPrompt ?? defaults.systemPrompt,
+    cwd: resolvedCwd,
+    reasoningLevel: config.reasoningLevel ?? "off",
+    maxSteps: config.maxSteps ?? defaults.maxSteps,
+    maxOutputTokens: config.maxOutputTokens ?? defaults.maxOutputTokens,
+    streamProvider: effectiveStreamProvider
   };
 }
-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;
+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,
+    getUsableTokenLimit({ contextWindow, reserveTokens })
+  );
+  const requestedProtected = compactionConfig.protectedTokens ?? DEFAULT_CONTEXT_LIMITS.protectedTokens;
+  const requestedPruneMinimum = compactionConfig.pruneMinimum ?? DEFAULT_CONTEXT_LIMITS.pruneMinimum;
   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 } : {},
-    ...options.reserveTokens !== void 0 ? { reserveTokens: options.reserveTokens } : {},
-    ...config.streamProvider ? { streamProvider: config.streamProvider } : {},
-    ...telemetrySettings ? { telemetry: telemetrySettings } : {}
+    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))
+    )
   };
 }
 
-// src/agent/chat-loop/commit.ts
-function createChatLoopCommitBatchApplier(params) {
-  const { turnEngine, sessions, middlewareRunner } = params;
-  return async function* applyCommitBatch(batch, options = {}) {
-    turnEngine.recordEvent(batch.startBoundary, (/* @__PURE__ */ new Date()).toISOString());
-    middlewareRunner.emitEvent(batch.startBoundary);
-    yield batch.startBoundary;
-    await sessions.addMessages(batch.messages);
-    turnEngine.recordEvent(batch.finishBoundary, (/* @__PURE__ */ new Date()).toISOString());
-    middlewareRunner.emitEvent(batch.finishBoundary);
-    yield batch.finishBoundary;
-    if (options.emitMessages) {
-      for (const committedMessage of batch.messages) {
-        yield { type: "message", message: committedMessage };
-      }
+// src/agent/setup/context-window.ts
+function createAgentContextWindowManager(config) {
+  const compactionConfig = config.compaction ?? {};
+  const modelId = extractModelId(config.model);
+  const inferredWindow = inferContextWindow(modelId);
+  const contextWindow = config.contextWindow ?? inferredWindow ?? DEFAULT_CONTEXT_LIMITS.contextWindow;
+  return new ContextWindowManager({
+    limits: {
+      contextWindow,
+      ...resolveAgentContextLimits(contextWindow, compactionConfig)
+    },
+    model: config.model,
+    summary: {
+      mode: compactionConfig.summaryMode ?? "required",
+      model: compactionConfig.summaryModel,
+      prompt: compactionConfig.summaryPrompt,
+      maxInputTokens: compactionConfig.summaryMaxInputTokens,
+      maxOutputTokens: compactionConfig.summaryMaxOutputTokens,
+      targetRatio: compactionConfig.summaryTargetRatio
     }
-  };
+  });
 }
 
-// src/agent/chat-loop/compaction.ts
-async function runAutoCompaction(params) {
-  const { contextManager, sessions, logger } = params;
-  const messages = sessions.getMessages();
-  if (!contextManager.shouldPrune(messages)) {
-    return [];
+// src/human/controller.ts
+var HumanInputTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Human input request timed out after ${timeoutMs}ms`);
+    this.name = "HumanInputTimeoutError";
   }
-  const events = [{ type: "status", status: "processing" }];
-  try {
-    const pruneResult = await compactAgentContext({
-      contextManager,
-      sessions,
-      logger
-    });
-    if (pruneResult.removedCount > 0 || pruneResult.summarized) {
-      const limits = contextManager.getLimits();
-      events.push({
-        type: "context-overflow",
-        inputTokens: estimateConversationTokens(messages),
-        limit: getUsableTokenLimit(limits)
-      });
-    }
-  } catch (error) {
-    logger?.warn("Auto-compaction failed, continuing without compaction", {
-      error: error instanceof Error ? error.message : String(error)
-    });
+};
+var HumanInputUnavailableError = class extends Error {
+  constructor() {
+    super("No human input controller configured");
+    this.name = "HumanInputUnavailableError";
   }
-  return events;
-}
-
-// src/agent/chat-loop/prompts.ts
-async function buildChatSystemPrompts(params) {
-  return buildAgentSystemPrompts({
-    config: params.config,
-    toolIds: Object.keys(params.tools),
-    sessionId: params.sessionId,
-    override: params.systemOverride,
-    promptBuilder: params.promptBuilder,
-    middlewareRunner: params.middlewareRunner
-  });
+};
+function cloneRecord(record) {
+  return structuredClone(record);
 }
-
-// src/agent/chat-loop/turn-tools.ts
-async function resolveTurnTools(options) {
-  const tools = /* @__PURE__ */ new Map();
-  const mcpTools = {};
-  const cleanup = [];
-  try {
-    for (const provider of options.providers) {
-      const resolved = await provider.resolveTools(options.context);
-      if (resolved.cleanup) {
-        cleanup.push(resolved.cleanup);
-      }
-      for (const tool of resolved.tools ?? []) {
-        if (options.baseTools.has(tool.id) || tools.has(tool.id)) {
-          throw new Error(
-            `Turn tool provider "${provider.name}" returned duplicate tool "${tool.id}"`
-          );
-        }
-        tools.set(tool.id, tool);
-      }
-      for (const [name, tool] of Object.entries(resolved.mcpTools ?? {})) {
-        if (options.baseMcpTools[name] || mcpTools[name]) {
-          throw new Error(
-            `Turn tool provider "${provider.name}" returned duplicate MCP tool "${name}"`
-          );
-        }
-        mcpTools[name] = tool;
-      }
-    }
-  } catch (error) {
-    try {
-      await cleanupTurnTools(cleanup);
-    } catch {
-    }
-    throw error;
+function normalizeStatuses(status) {
+  if (!status) {
+    return void 0;
   }
-  return { tools, mcpTools, cleanup };
+  return new Set(Array.isArray(status) ? status : [status]);
 }
-function mergeTurnTools(baseTools, turnTools) {
-  if (turnTools.size === 0) {
-    return baseTools;
+function inferKind(input) {
+  if (input.kind) {
+    return input.kind;
   }
-  const merged = new Map(baseTools);
-  for (const [id, tool] of turnTools) {
-    if (merged.has(id)) {
-      throw new Error(`Turn-scoped tool "${id}" conflicts with an agent tool`);
-    }
-    merged.set(id, tool);
+  if (input.options && input.options.length > 0) {
+    return "choice";
   }
-  return merged;
+  return "text";
 }
-async function cleanupTurnTools(cleanup) {
-  const errors = [];
-  for (const cleanupFn of [...cleanup].reverse()) {
-    try {
-      await cleanupFn();
-    } catch (error) {
-      errors.push(error);
-    }
-  }
-  if (errors.length === 1) {
-    throw errors[0];
-  }
-  if (errors.length > 1) {
-    throw new AggregateError(
-      errors,
-      "Multiple turn tool cleanup callbacks failed"
-    );
+function isHumanInputController(value) {
+  if (!value || typeof value !== "object") {
+    return false;
   }
+  const candidate = value;
+  return typeof candidate.request === "function" && typeof candidate.respondToRequest === "function" && typeof candidate.getRequest === "function" && typeof candidate.listRequests === "function" && typeof candidate.cancelAll === "function";
 }
-
-// src/agent/chat-loop/loop.ts
-async function* runChatLoop(deps) {
-  yield* streamWithinScope(
-    {
-      kind: "turn",
-      name: "agent-turn",
-      sessionId: deps.sessionId
-    },
-    (async function* () {
-      const {
-        sessionId,
-        turnId,
-        message,
-        abort,
-        systemOverride,
-        sessions,
-        tools: liveTools,
-        config,
-        turnTracker,
-        interventionCtrl,
-        middlewareRunner,
-        contextManager,
-        rememberedDoomLoopTools,
-        reasoningLevel,
-        promptBuilder,
-        host,
-        humanInputController,
-        mcpTools,
-        toModelMessages,
-        setIsStreaming
-      } = deps;
-      let resolvedTurnTools;
-      try {
-        resolvedTurnTools = await resolveTurnTools({
-          providers: deps.turnToolProviders,
-          context: {
-            sessionId,
-            turnId,
-            message,
-            cwd: config.cwd,
-            abort
-          },
-          baseTools: liveTools,
-          baseMcpTools: mcpTools
-        });
-      } catch (error) {
-        const errorInstance = error instanceof Error ? error : new Error(String(error));
-        const statusEvent = { type: "status", status: "error" };
-        middlewareRunner.emitEvent(statusEvent);
-        yield statusEvent;
-        const errorEvent = {
-          type: "error",
-          error: errorInstance
-        };
-        middlewareRunner.emitEvent(errorEvent);
-        yield errorEvent;
-        throw errorInstance;
-      }
-      const turnMcpTools = {
-        ...mcpTools,
-        ...resolvedTurnTools.mcpTools
-      };
-      let toolRecord = createAgentToolRecord(
-        mergeTurnTools(liveTools, resolvedTurnTools.tools)
-      );
-      const prevOnApplied = interventionCtrl.onApplied;
-      let streamingStateStarted = false;
-      let chatUsage;
-      let chatError;
-      let chatOutput;
-      let chatEndError;
-      let rethrowError;
-      const lifecycleContext = {
-        sessionId,
-        turnId,
-        history: {
-          getRecentMessages: (options) => sessions.getRecentMessages(options)
-        }
-      };
-      try {
-        const isPlanMode = deps.toolExecutionMode === "plan";
-        const turnEngine = createAgentTurnEngine({
-          sessionId,
-          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          getToolReplayPolicy: (toolName) => toolRecord[toolName] ? normalizeToolReplayPolicy(toolRecord[toolName].replayPolicy) : void 0
-        });
-        const applyCommitBatch = createChatLoopCommitBatchApplier({
-          turnEngine,
-          sessions,
-          middlewareRunner
-        });
-        yield* applyCommitBatch(
-          turnEngine.createInputCommit({
-            content: message,
-            system: systemOverride
-          }),
-          { emitMessages: true }
-        );
-        setIsStreaming(true);
-        streamingStateStarted = true;
-        if (middlewareRunner.hasMiddleware) {
-          await middlewareRunner.runChatStart(
-            sessionId,
-            message,
-            lifecycleContext
-          );
-        }
-        let step = 1;
-        let finalStepText = "";
-        let accumulatedUsage;
-        while (step <= config.maxSteps) {
-          toolRecord = createAgentToolRecord(
-            mergeTurnTools(liveTools, resolvedTurnTools.tools)
-          );
-          const systemPrompts = await buildChatSystemPrompts({
-            promptBuilder,
-            middlewareRunner,
-            systemOverride,
-            sessionId,
-            config,
-            tools: toolRecord
-          });
-          const preparedStep = prepareModelStep({
-            sessionId,
-            step,
-            systemPrompts,
-            messages: sessions.getMessages(),
-            toModelMessages,
-            abort,
-            tools: toolRecord,
-            mcpTools: turnMcpTools,
-            config,
-            host,
-            humanInputController,
-            turnTracker,
-            intervention: interventionCtrl,
-            middleware: middlewareRunner,
-            reasoningLevel,
-            toolExecutionMode: deps.toolExecutionMode
-          });
-          const stepResult = yield* runModelStep({
-            preparedStep,
-            turnEngine,
-            applyCommitBatch,
-            rememberedDoomLoopTools
-          });
-          accumulatedUsage = accumulateUsage(
-            accumulatedUsage,
-            stepResult.usage
-          );
-          if (stepResult.error) {
-            chatError = stepResult.error;
+async function emitHumanInputEvent(context, event) {
+  await context?.emitEvent?.(event);
+}
+function createHumanInputController(config = {}) {
+  const timeout = config.timeout ?? 5 * 60 * 1e3;
+  let requestCounter = 0;
+  const pending = /* @__PURE__ */ new Map();
+  async function request(sessionId, input, context = {}) {
+    const requestPayload = {
+      id: `human-input-${++requestCounter}-${Date.now()}`,
+      sessionId,
+      kind: inferKind(input),
+      title: input.title,
+      question: input.question,
+      ...input.options ? { options: input.options.map((option) => ({ ...option })) } : {},
+      ...input.allowMultiple !== void 0 ? { allowMultiple: input.allowMultiple } : {},
+      ...input.placeholder ? { placeholder: input.placeholder } : {},
+      ...input.confirmLabel ? { confirmLabel: input.confirmLabel } : {},
+      ...input.denyLabel ? { denyLabel: input.denyLabel } : {},
+      ...input.toolCallId ? { toolCallId: input.toolCallId } : {},
+      timestamp: Date.now()
+    };
+    const record = {
+      id: requestPayload.id,
+      sessionId,
+      request: structuredClone(requestPayload),
+      status: "pending",
+      createdAt: requestPayload.timestamp,
+      updatedAt: requestPayload.timestamp
+    };
+    const responsePromise = new Promise(
+      (resolve2, reject) => {
+        const timeoutId = setTimeout(() => {
+          const current2 = pending.get(record.id);
+          if (!current2) {
             return;
           }
-          const planSnapshot = isPlanMode && stepResult.finishReason === "tool-calls" ? turnEngine.createStepCommitSnapshot() : void 0;
-          yield* commitStep({
-            step,
-            finishReason: stepResult.finishReason,
-            turnEngine,
-            applyCommitBatch
-          });
-          if (stepResult.finishReason === "tool-calls") {
-            if (step >= config.maxSteps) {
-              const maxStepsError = new Error(
-                `Maximum steps (${config.maxSteps}) reached before the turn produced a final response`
-              );
-              chatError = maxStepsError;
-              const statusEvent = {
-                type: "status",
-                status: "error"
-              };
-              middlewareRunner.emitEvent(statusEvent);
-              yield statusEvent;
-              const errorEvent = {
-                type: "error",
-                error: maxStepsError
-              };
-              middlewareRunner.emitEvent(errorEvent);
-              yield errorEvent;
-              return;
-            }
-            if (isPlanMode && planSnapshot && planSnapshot.toolCalls.length > 0) {
-              const batchResult = await runToolBatch({
-                sessionId,
-                snapshot: planSnapshot,
-                tools: toolRecord,
-                cwd: config.cwd,
-                abort,
-                host,
-                humanInputController,
-                turnTracker,
-                middleware: middlewareRunner,
-                intervention: interventionCtrl
-              });
-              for (const event of batchResult.events) {
-                turnEngine.recordEvent(event, (/* @__PURE__ */ new Date()).toISOString());
-                middlewareRunner.emitEvent(event);
-                yield event;
-              }
-              yield* commitStep({
-                step,
-                finishReason: "tool-calls",
-                turnEngine,
-                applyCommitBatch
-              });
-            }
-            step += 1;
-            continue;
+          pending.delete(record.id);
+          current2.record = {
+            ...current2.record,
+            status: "timed-out",
+            updatedAt: Date.now()
+          };
+          void emitHumanInputEvent(
+            { emitEvent: current2.emitEvent },
+            { type: "status", status: "processing" }
+          );
+          reject(new HumanInputTimeoutError(timeout));
+        }, timeout);
+        pending.set(record.id, {
+          record,
+          resolve: resolve2,
+          reject,
+          ready: Promise.resolve(),
+          timeoutId,
+          emitEvent: context.emitEvent
+        });
+      }
+    );
+    const current = pending.get(record.id);
+    if (current) {
+      current.ready = (async () => {
+        await emitHumanInputEvent(context, {
+          type: "status",
+          status: "waiting-input"
+        });
+        await emitHumanInputEvent(context, {
+          type: "human-input-request",
+          request: {
+            id: requestPayload.id,
+            kind: requestPayload.kind,
+            title: requestPayload.title,
+            question: requestPayload.question,
+            ...requestPayload.options ? { options: requestPayload.options } : {},
+            ...requestPayload.allowMultiple !== void 0 ? { allowMultiple: requestPayload.allowMultiple } : {},
+            ...requestPayload.placeholder ? { placeholder: requestPayload.placeholder } : {},
+            ...requestPayload.confirmLabel ? { confirmLabel: requestPayload.confirmLabel } : {},
+            ...requestPayload.denyLabel ? { denyLabel: requestPayload.denyLabel } : {}
           }
-          finalStepText = stepResult.text;
-          break;
-        }
-        yield* commitOutput({
-          text: finalStepText,
-          usage: accumulatedUsage,
-          turnEngine,
-          applyCommitBatch
         });
-        if (config.compaction?.auto !== false) {
-          const compactionEvents = await runAutoCompaction({
-            contextManager,
-            sessions,
-            logger: deps.logger
-          });
-          for (const event of compactionEvents) {
-            yield event;
+      })();
+    }
+    if (config.onRequest) {
+      void (async () => {
+        try {
+          await pending.get(record.id)?.ready;
+          const response = await config.onRequest(requestPayload);
+          await respondToRequest(record.id, response, context);
+        } catch (error) {
+          if (error instanceof HumanInputTimeoutError) {
+            return;
           }
-        }
-        const turnSummary = await turnTracker.endTurn();
-        if (turnSummary.totalTracked > 0) {
-          yield {
-            type: "turn-summary",
-            turnId: turnSummary.turnId,
-            files: turnSummary.files.map((file) => ({
-              path: file.path,
-              type: file.type,
-              additions: file.additions,
-              deletions: file.deletions
-            })),
-            additions: turnSummary.additions,
-            deletions: turnSummary.deletions
+          const current2 = pending.get(record.id);
+          if (!current2) {
+            return;
+          }
+          pending.delete(record.id);
+          clearTimeout(current2.timeoutId);
+          current2.record = {
+            ...current2.record,
+            status: "cancelled",
+            updatedAt: Date.now()
           };
+          current2.reject(
+            error instanceof Error ? error : new Error(String(error))
+          );
+          await emitHumanInputEvent(
+            { emitEvent: current2.emitEvent },
+            { type: "status", status: "processing" }
+          );
         }
-        chatUsage = accumulatedUsage;
-        chatOutput = finalStepText || void 0;
-        yield {
-          type: "complete",
-          usage: accumulatedUsage,
-          output: finalStepText || void 0
-        };
-      } 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;
-        rethrowError = error;
-      } finally {
-        if (streamingStateStarted) {
-          setIsStreaming(false);
-        }
-        interventionCtrl.onApplied = prevOnApplied;
-        if (middlewareRunner.hasMiddleware) {
-          try {
-            await middlewareRunner.runChatEnd(
-              sessionId,
-              {
-                usage: chatUsage,
-                error: chatError,
-                output: chatOutput
-              },
-              lifecycleContext
-            );
-          } catch (error) {
-            chatEndError = error;
-          }
+      })();
+    }
+    return await responsePromise;
+  }
+  async function respondToRequest(requestId, response, context = {}) {
+    const current = pending.get(requestId);
+    if (!current) {
+      throw new Error(`Human input request not found: ${requestId}`);
+    }
+    await current.ready;
+    pending.delete(requestId);
+    clearTimeout(current.timeoutId);
+    const respondedAt = Date.now();
+    const next = {
+      ...current.record,
+      status: "answered",
+      updatedAt: respondedAt,
+      respondedAt,
+      response: structuredClone(response)
+    };
+    current.resolve(response);
+    const emitEvent = context.emitEvent ?? current.emitEvent;
+    await emitHumanInputEvent(
+      { emitEvent },
+      {
+        type: "human-input-resolved",
+        id: requestId,
+        response
+      }
+    );
+    await emitHumanInputEvent(
+      { emitEvent },
+      { type: "status", status: "processing" }
+    );
+    return cloneRecord(next);
+  }
+  function getRequest(requestId) {
+    const current = pending.get(requestId);
+    return current ? cloneRecord(current.record) : void 0;
+  }
+  function listRequests(options = {}) {
+    const statuses = normalizeStatuses(options.status);
+    return [...pending.values()].map((entry) => cloneRecord(entry.record)).filter((record) => {
+      if (options.sessionId && record.sessionId !== options.sessionId) {
+        return false;
+      }
+      if (statuses && !statuses.has(record.status)) {
+        return false;
+      }
+      return true;
+    }).sort((left, right) => left.createdAt - right.createdAt);
+  }
+  function cancelAll(reason = "Cancelled") {
+    for (const [requestId, current] of pending) {
+      pending.delete(requestId);
+      clearTimeout(current.timeoutId);
+      current.record = {
+        ...current.record,
+        status: "cancelled",
+        updatedAt: Date.now()
+      };
+      current.reject(new Error(reason));
+      void emitHumanInputEvent(
+        { emitEvent: current.emitEvent },
+        { type: "status", status: "processing" }
+      );
+    }
+  }
+  return {
+    get hasPendingRequests() {
+      return pending.size > 0;
+    },
+    request,
+    respondToRequest,
+    getRequest,
+    listRequests,
+    cancelAll
+  };
+}
+
+// src/human/handler.ts
+function createHumanInputHandler(config = {}) {
+  return createHumanInputController(config);
+}
+
+// src/human/tool.ts
+import { z } from "zod";
+function createHumanInputTool(options = {}) {
+  if (options.controller) {
+    return createHumanInputToolWithController(options.controller, options);
+  }
+  if (options.onRequest || options.timeout !== void 0) {
+    return createHumanInputToolWithController(
+      createHumanInputController(options),
+      options
+    );
+  }
+  return createHumanInputToolWithController(void 0, options);
+}
+function createHumanInputToolWithController(controller, options = {}) {
+  return Tool.define(
+    options.name ?? "question",
+    {
+      description: options.description ?? "Ask a human for missing input, a decision, a confirmation, or a choice.",
+      parameters: z.object({
+        title: z.string().min(1).describe("Short heading for the request"),
+        question: z.string().min(1).describe("What to ask the human"),
+        kind: z.enum(["text", "confirm", "choice"]).optional(),
+        options: z.array(
+          z.object({
+            label: z.string().min(1),
+            value: z.string().optional(),
+            description: z.string().optional()
+          })
+        ).optional(),
+        allowMultiple: z.boolean().optional(),
+        placeholder: z.string().optional(),
+        confirmLabel: z.string().optional(),
+        denyLabel: z.string().optional()
+      }),
+      validate: (params) => {
+        const kind = params.kind ?? (params.options?.length ? "choice" : "text");
+        if (kind === "choice" && (!params.options || params.options.length === 0)) {
+          return {
+            ok: false,
+            reason: "Choice requests must include at least one option."
+          };
         }
+        if (kind !== "choice" && params.allowMultiple) {
+          return {
+            ok: false,
+            reason: "allowMultiple is only valid for choice requests."
+          };
+        }
+        return { ok: true };
+      },
+      capabilities: {
+        readOnly: true,
+        riskLevel: "safe",
+        parallelSafe: false,
+        humanInput: true
+      },
+      replayPolicy: {
+        mode: "manual",
+        sideEffectLevel: "external",
+        reason: "Depends on a human response before execution can continue."
+      },
+      execute: async (params, ctx) => {
+        let response;
         try {
-          await cleanupTurnTools(resolvedTurnTools.cleanup);
+          const activeController = controller ?? ctx.humanInputController;
+          if (!activeController) {
+            throw new HumanInputUnavailableError();
+          }
+          response = await activeController.request(
+            ctx.sessionID,
+            {
+              ...params,
+              toolCallId: typeof ctx.extra?.toolCallId === "string" ? ctx.extra.toolCallId : ctx.messageID
+            },
+            {
+              emitEvent: ctx.emitEvent
+            }
+          );
         } catch (error) {
-          const errorInstance = error instanceof Error ? error : new Error(String(error));
-          deps.logger?.warn("Turn tool provider cleanup failed", {
-            error: errorInstance,
-            message: errorInstance.message,
-            stack: errorInstance.stack
-          });
+          if (error instanceof HumanInputUnavailableError) {
+            throw error;
+          }
+          throw error;
         }
+        return {
+          title: params.title,
+          output: response.text,
+          metadata: { response }
+        };
       }
-      if (chatEndError) {
-        throw chatEndError;
-      }
-      if (rethrowError) {
-        throw rethrowError;
+    },
+    {
+      replayPolicy: {
+        mode: "manual",
+        sideEffectLevel: "external",
+        reason: "Depends on a human response before execution can continue."
+      },
+      capabilitiesHint: {
+        readOnly: true,
+        riskLevel: "safe",
+        parallelSafe: false,
+        humanInput: true
       }
-    })()
+    }
   );
 }
+var createHumanInputToolWithHandler = createHumanInputToolWithController;
 
-// src/agent/fork.ts
-function resolveForkOptions(options, parentTools, systemPrompt) {
-  if (!options.profile) {
-    return options;
+// src/agent/setup/environment.ts
+function resolveHumanInputController(input) {
+  if (!input.humanInput) {
+    return {};
   }
-  const applied = applyProfile(options.profile, parentTools, systemPrompt);
   return {
-    ...applied,
-    ...options,
-    tools: options.tools ?? applied.tools
+    humanInputController: isHumanInputController(input.humanInput) ? input.humanInput : createHumanInputController(input.humanInput)
   };
 }
-function resolveChildPromptConfig(options) {
-  const { forkOptions, promptBuilder, parentPromptConfig, parentSystemPrompt } = options;
-  if (forkOptions.systemPrompt) {
-    return { systemPrompt: forkOptions.systemPrompt };
+function resolveExecutionEnvironment(input, config) {
+  if (input.host !== void 0 && input.sandbox !== void 0 && input.host !== input.sandbox.host) {
+    throw new Error(
+      "createAgent() received both `host` and `sandbox`, but `sandbox.host` does not match the provided host. Pass only one execution input, or reuse the same host instance for both."
+    );
   }
-  if (forkOptions.prompt) {
-    return { prompt: forkOptions.prompt };
+  if (input.host !== void 0) {
+    return {
+      host: input.host,
+      ...input.sandbox ? { sandbox: input.sandbox } : {},
+      ownsHost: false
+    };
   }
-  if (promptBuilder) {
-    return { prompt: parentPromptConfig ?? {} };
+  if (input.sandbox !== void 0) {
+    return {
+      host: input.sandbox.host,
+      sandbox: input.sandbox,
+      ownsHost: false
+    };
   }
-  return { systemPrompt: parentSystemPrompt };
+  return {
+    host: localHost(config.cwd),
+    ownsHost: true
+  };
 }
-function resolveForkMiddleware(options, middlewareRunner) {
-  if (options.middleware) {
-    return options.middleware;
+
+// src/agent/setup/middleware.ts
+function createMiddlewareSetup(input, config) {
+  const inputMiddleware = [...input.middleware ?? []];
+  const hasManualApprovalMiddleware = inputMiddleware.some(
+    (mw) => isApprovalMiddleware(mw)
+  );
+  if (input.approval && hasManualApprovalMiddleware) {
+    throw new Error(
+      "createAgent() received both `approval` config and an explicit approval middleware. Use `approval` for the built-in sugar, or install `approvalMiddleware(...)` manually, but not both."
+    );
   }
-  if (options.additionalMiddleware) {
-    return [
-      ...middlewareRunner.getMiddleware(),
-      ...options.additionalMiddleware
+  let effectiveMiddleware = inputMiddleware;
+  let telemetrySettings;
+  let tracingShutdown;
+  const memory = resolveAgentMemoryConfig(input.memory);
+  if (memory) {
+    effectiveMiddleware.push(
+      createMemoryMiddleware({
+        provider: memory.provider,
+        recall: memory.recall,
+        turns: memory.turns,
+        cwd: config.cwd
+      })
+    );
+  }
+  if (input.approval) {
+    effectiveMiddleware.push(approvalMiddleware(input.approval));
+  }
+  if (input.tracing) {
+    const agentName = config.name ?? DEFAULT_AGENT_NAME;
+    const telemetryResult = createTelemetryConfig({
+      ...input.tracing,
+      agentName,
+      serviceName: input.tracing.serviceName ?? agentName
+    });
+    effectiveMiddleware = [
+      ...telemetryResult.middlewares.length > 0 ? telemetryResult.middlewares : [telemetryResult.middleware],
+      ...effectiveMiddleware
     ];
+    telemetrySettings = telemetryResult.telemetry;
+    tracingShutdown = telemetryResult.shutdown;
   }
-  return [...middlewareRunner.getMiddleware()];
+  return {
+    middlewareRunner: new MiddlewareRunner(effectiveMiddleware, input.logger),
+    ...telemetrySettings ? { telemetrySettings } : {},
+    ...tracingShutdown ? { tracingShutdown } : {}
+  };
 }
-function createForkedAgentConfig(options) {
-  const {
-    forkOptions,
-    parentConfig,
-    parentTools,
-    reasoningLevel,
-    host,
-    sandbox,
-    humanInputController,
-    ownsHost,
-    sessions,
-    mcpManager,
-    middlewareRunner,
-    promptBuilder
-  } = options;
-  const tools = forkOptions.tools ?? parentTools;
-  const childPrompt = resolveChildPromptConfig({
-    forkOptions,
-    promptBuilder,
-    parentPromptConfig: parentConfig.prompt,
-    parentSystemPrompt: parentConfig.systemPrompt
-  });
+
+// src/agent/setup/state.ts
+function resolveInitialReasoningLevel(config) {
+  const reasoningConfig = getReasoningConfigSync(config.model);
+  const requestedLevel = config.reasoningLevel ?? "off";
+  return reasoningConfig.availableLevels.includes(requestedLevel) ? requestedLevel : reasoningConfig.availableLevels[0];
+}
+function createAgentState(config) {
   return {
-    model: forkOptions.model ?? parentConfig.model,
-    cwd: parentConfig.cwd,
-    ...ownsHost ? {} : sandbox !== void 0 ? { sandbox } : { host },
-    ...humanInputController ? { humanInput: humanInputController } : {},
-    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,
-    turnToolProviders: forkOptions.turnToolProviders ?? parentConfig.turnToolProviders,
-    middleware: resolveForkMiddleware(forkOptions, middlewareRunner)
+    model: config.model,
+    reasoningLevel: resolveInitialReasoningLevel(config)
   };
 }
 
-// src/agent/mcp-bridge.ts
-async function ensureMcpTools(state, logger) {
-  if (!state.manager) {
-    return { connected: false, cachedTools: void 0 };
+// src/agent/setup/tools.ts
+function createToolMap(tools) {
+  const toolMap = /* @__PURE__ */ new Map();
+  for (const tool of tools ?? []) {
+    toolMap.set(tool.id, tool);
   }
-  if (state.connected && state.cachedTools) {
-    return {
-      connected: state.connected,
-      cachedTools: state.cachedTools
-    };
+  return toolMap;
+}
+function createAgentTools(input) {
+  const memory = resolveAgentMemoryConfig(input.memory);
+  const tools = [...input.tools ?? []];
+  if (memory?.tools.enabled) {
+    tools.push(
+      ...memory.provider.getTools?.({
+        deferred: memory.tools.deferred
+      }) ?? []
+    );
   }
-  const log = logger.child("mcp");
-  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") {
-      log.warn(`Failed to connect to ${name}: ${status.error}`);
+  return {
+    tools: createToolMap(tools),
+    ...memory ? { memoryProvider: memory.provider } : {}
+  };
+}
+
+// src/agent/setup.ts
+function createAgentSetup(input) {
+  const promptBuilder = createAgentPromptBuilder(input);
+  const config = createEffectiveAgentConfig(input);
+  const middlewareSetup = createMiddlewareSetup(input, config);
+  const toolSetup = createAgentTools(input);
+  const humanInputSetup = resolveHumanInputController(input);
+  const executionEnvironment = resolveExecutionEnvironment(input, config);
+  const logger = input.logger ?? silentLogger;
+  return {
+    config,
+    tools: toolSetup.tools,
+    sessions: input.sessionManager ?? getDefaultSessionManager(),
+    sessionTurnLock: input.sessionTurnLock ?? new LocalSessionTurnLock(),
+    state: createAgentState(config),
+    contextManager: createAgentContextWindowManager(config),
+    turnTracker: createTurnTracker({ cwd: config.cwd }, logger),
+    ...input.mcp ? { mcpManager: input.mcp } : {},
+    turnToolProviders: [...input.turnToolProviders ?? []],
+    ...promptBuilder ? { promptBuilder } : {},
+    interventionCtrl: new InterventionController(),
+    ...humanInputSetup,
+    ...executionEnvironment,
+    middlewareRunner: middlewareSetup.middlewareRunner,
+    ...toolSetup.memoryProvider ? { memoryProvider: toolSetup.memoryProvider } : {},
+    logger,
+    ...middlewareSetup.telemetrySettings ? { telemetrySettings: middlewareSetup.telemetrySettings } : {},
+    ...middlewareSetup.tracingShutdown ? { tracingShutdown: middlewareSetup.tracingShutdown } : {}
+  };
+}
+
+// src/agent/turn-context/compaction/budget.ts
+function normalizeTransientContextTokens(value) {
+  if (!Number.isFinite(value) || value === void 0 || value <= 0) return 0;
+  return Math.floor(value);
+}
+function reserveTransientContextBudget(limits, transientContextTokens) {
+  if (transientContextTokens <= 0) return limits;
+  const usableLimit = getUsableTokenLimit(limits);
+  const transientUsableLimit = Math.max(
+    1,
+    usableLimit - transientContextTokens
+  );
+  return {
+    ...limits,
+    contextWindow: transientUsableLimit + limits.reserveTokens,
+    protectedTokens: Math.min(
+      limits.protectedTokens,
+      Math.max(1, Math.round(transientUsableLimit * 0.6))
+    ),
+    pruneMinimum: Math.min(
+      limits.pruneMinimum,
+      Math.max(1, Math.round(transientUsableLimit * 0.5))
+    )
+  };
+}
+
+// src/agent/turn-context/compaction/fragments.ts
+function stripSummaryPreviewMessage(messages, summary) {
+  if (!summary) return messages;
+  const firstMessage = messages[0];
+  if (firstMessage && extractCompactionSummaryText(firstMessage) === summary) {
+    return messages.slice(1);
+  }
+  return messages;
+}
+function contextFragmentIdentity(message) {
+  const metadata = getAgentContextFragmentMetadata(message);
+  if (!metadata) return void 0;
+  return metadata.dedupeKey ?? metadata.id;
+}
+function collectDurableContextFragments(removedMessages, keptMessages) {
+  const keptIdentities = new Set(
+    keptMessages.map(contextFragmentIdentity).filter((identity) => identity !== void 0)
+  );
+  const preserved = [];
+  const preservedIdentities = /* @__PURE__ */ new Set();
+  for (const message of removedMessages) {
+    const metadata = getAgentContextFragmentMetadata(message);
+    if (!metadata || metadata.lifetime !== "session") continue;
+    const identity = contextFragmentIdentity(message);
+    if (identity && (keptIdentities.has(identity) || preservedIdentities.has(identity))) {
+      continue;
     }
+    if (identity) {
+      preservedIdentities.add(identity);
+    }
+    preserved.push(message);
   }
-  if (connectedCount === 0 && statuses.size > 0) {
-    log.warn("No MCP servers connected successfully");
+  return preserved;
+}
+
+// src/agent/turn-context/compaction/memory.ts
+async function prepareMemoryForCompaction(options) {
+  if (!options.provider?.prepareForCompaction) return;
+  if (options.removedMessages.length === 0) return;
+  try {
+    await options.provider.prepareForCompaction({
+      sessionId: options.sessionId ?? "unknown",
+      ...options.turnId ? { turnId: options.turnId } : {},
+      cwd: options.cwd ?? process.cwd(),
+      ...options.phase ? { phase: options.phase } : {},
+      removedMessages: options.removedMessages,
+      keptMessages: options.keptMessages,
+      ...options.summary ? { summary: options.summary } : {},
+      ...options.abort ? { abort: options.abort } : {}
+    });
+  } catch (error) {
+    options.logger.warn("Memory provider compaction hook failed", {
+      providerId: options.provider.id,
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
-  const cachedTools = await state.manager.getTools();
+}
+
+// src/agent/turn-context/compaction/results.ts
+function createUnchangedCompactionResult(options) {
   return {
-    connected: true,
-    cachedTools
+    compacted: false,
+    messages: [...options.messages],
+    persistedMessages: [...options.messages],
+    decision: options.decision,
+    effectiveness: createCompactionEffectiveness(
+      options.tokensBefore,
+      options.tokensBefore
+    ),
+    displaySummary: false,
+    storageSummary: "No context compaction was needed.",
+    removedCount: 0,
+    tokensRemoved: 0,
+    summarized: false,
+    summary: void 0,
+    cutIndex: options.cutIndex,
+    cutReason: options.cutReason,
+    tokensBefore: options.tokensBefore,
+    tokensAfter: options.tokensBefore,
+    limit: options.limit
   };
 }
-async function closeMcpManager(manager) {
-  if (manager) {
-    await manager.close();
-  }
+function createToolContextCompactionResult(options) {
+  const { messages, tokensBefore } = options;
+  const tokensAfter = estimateConversationTokens(messages);
   return {
-    connected: false,
-    cachedTools: void 0
+    compacted: true,
+    messages,
+    persistedMessages: messages,
+    decision: options.decision,
+    effectiveness: createCompactionEffectiveness(tokensBefore, tokensAfter),
+    displaySummary: false,
+    storageSummary: "Large historical tool context was compacted.",
+    removedCount: 0,
+    tokensRemoved: Math.max(0, tokensBefore - tokensAfter),
+    summarized: false,
+    summary: void 0,
+    cutIndex: 0,
+    cutReason: void 0,
+    tokensBefore,
+    tokensAfter,
+    limit: options.limit
   };
 }
 
-// src/signal/local.ts
-var LocalSignal = class {
-  /** type → Set<handler> for typed subscriptions */
-  typed = /* @__PURE__ */ new Map();
-  /** handlers that receive every event */
-  wildcard = /* @__PURE__ */ new Set();
-  on(type, handler) {
-    let set = this.typed.get(type);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.typed.set(type, set);
-    }
-    const wrapped = (event) => {
-      handler(event);
-    };
-    set.add(wrapped);
-    return () => {
-      set.delete(wrapped);
-      if (set.size === 0) this.typed.delete(type);
-    };
-  }
-  onAny(handler) {
-    this.wildcard.add(handler);
-    return () => {
-      this.wildcard.delete(handler);
-    };
+// src/agent/turn-context/compaction/summary.ts
+function buildFallbackCompactionSummary(messages) {
+  const serialized = serializeMessagesForSummary(messages, {
+    maxInputTokens: 2e3,
+    maxMessageTokens: 750
+  });
+  return serialized.length > 0 ? serialized : "Earlier conversation context was compacted.";
+}
+
+// src/agent/turn-context/compaction/agent-context.ts
+async function compactAgentMessages(options) {
+  const { contextManager, messages, logger, force = false } = options;
+  const log = logger ?? silentLogger;
+  const visibleMessages = [...messages];
+  const baseLimits = contextManager.getLimits();
+  const transientContextTokens = normalizeTransientContextTokens(
+    options.transientContextTokens
+  );
+  const compactionLimits = reserveTransientContextBudget(
+    baseLimits,
+    transientContextTokens
+  );
+  const limit = getUsableTokenLimit(compactionLimits);
+  const tokensBefore = estimateConversationTokens(visibleMessages);
+  const summaryPolicy = contextManager.getSummaryPolicy();
+  const canSummarize = canGenerateCompactionSummary(summaryPolicy);
+  const initialDecision = decideContextCompaction(visibleMessages, {
+    limits: baseLimits,
+    force,
+    canSummarize,
+    inputTokens: tokensBefore + transientContextTokens
+  });
+  if (!force && !initialDecision.needed) {
+    return createUnchangedCompactionResult({
+      messages: visibleMessages,
+      decision: initialDecision,
+      tokensBefore,
+      limit: getUsableTokenLimit(baseLimits)
+    });
   }
-  emit(event) {
-    const set = this.typed.get(event.type);
-    if (set) {
-      for (const fn of set) {
-        try {
-          fn(event);
-        } catch {
-        }
-      }
+  let removedCount = 0;
+  let summarized = false;
+  let summary;
+  let cutIndex;
+  let cutReason;
+  const decision = initialDecision;
+  let prunedMessages;
+  let pruneTokensRemoved = 0;
+  let keptMessagesFromPrune;
+  let fallbackRemovedMessages;
+  let fallbackKeptMessages;
+  try {
+    const result = await pruneContext(visibleMessages, {
+      limits: compactionLimits,
+      summary: summaryPolicy,
+      force
+    });
+    removedCount = result.removedCount;
+    pruneTokensRemoved = result.effectiveness.tokensRemoved;
+    summarized = result.summarized;
+    summary = result.summary;
+    cutIndex = result.cutIndex;
+    cutReason = result.cutReason;
+    prunedMessages = result.messages;
+    fallbackRemovedMessages = result.removedMessages;
+    if (removedCount > 0) {
+      keptMessagesFromPrune = stripSummaryPreviewMessage(
+        result.messages,
+        summary
+      );
+      fallbackKeptMessages = result.keptMessages;
     }
-    for (const fn of this.wildcard) {
-      try {
-        fn(event);
-      } catch {
-      }
+  } catch (pruneError) {
+    if (!shouldFallbackOnSummaryFailure({ policy: summaryPolicy, force })) {
+      throw pruneError;
     }
+    log.warn("Context compaction LLM summarisation failed, using fallback", {
+      error: pruneError instanceof Error ? pruneError.message : String(pruneError)
+    });
   }
-  clear() {
-    this.typed.clear();
-    this.wildcard.clear();
+  if (removedCount === 0 && prunedMessages && pruneTokensRemoved > 0 && !decideContextCompaction(prunedMessages, {
+    limits: compactionLimits,
+    canSummarize
+  }).needed) {
+    return createToolContextCompactionResult({
+      messages: prunedMessages,
+      decision,
+      tokensBefore,
+      limit
+    });
   }
-};
-
-// src/human/controller.ts
-var HumanInputTimeoutError = class extends Error {
-  constructor(timeoutMs) {
-    super(`Human input request timed out after ${timeoutMs}ms`);
-    this.name = "HumanInputTimeoutError";
+  if (removedCount === 0) {
+    const fallbackMessages = prunedMessages ?? visibleMessages;
+    const fallbackPlan = planCompactionCut(
+      fallbackMessages,
+      compactionLimits.protectedTokens,
+      {
+        allowSplitTurn: summaryPolicy.mode !== "disabled",
+        maxKeptTokens: getUsableTokenLimit(compactionLimits)
+      }
+    );
+    removedCount = fallbackPlan.cutIndex;
+    cutIndex = fallbackPlan.cutIndex;
+    cutReason = fallbackPlan.reason;
+    fallbackRemovedMessages = fallbackPlan.removedMessages;
+    fallbackKeptMessages = fallbackPlan.keptMessages;
   }
-};
-var HumanInputUnavailableError = class extends Error {
-  constructor() {
-    super("No human input controller configured");
-    this.name = "HumanInputUnavailableError";
+  if (removedCount === 0) {
+    if (prunedMessages && pruneTokensRemoved > 0) {
+      return createToolContextCompactionResult({
+        messages: prunedMessages,
+        decision,
+        tokensBefore,
+        limit
+      });
+    }
+    return createUnchangedCompactionResult({
+      messages: visibleMessages,
+      decision,
+      tokensBefore,
+      limit,
+      cutIndex,
+      cutReason
+    });
   }
-};
-function cloneRecord(record) {
-  return structuredClone(record);
-}
-function normalizeStatuses(status) {
-  if (!status) {
-    return void 0;
+  const removedMessages = fallbackRemovedMessages ?? visibleMessages.slice(0, removedCount);
+  const keptMessages = keptMessagesFromPrune ?? fallbackKeptMessages ?? visibleMessages.slice(removedCount);
+  const preservedContextFragments = collectDurableContextFragments(
+    removedMessages,
+    keptMessages
+  );
+  if (summaryPolicy.mode === "disabled" && !summary) {
+    const persistedMessages2 = [...preservedContextFragments, ...keptMessages];
+    const tokensAfter2 = estimateConversationTokens(persistedMessages2);
+    await prepareMemoryForCompaction({
+      provider: options.memoryProvider,
+      sessionId: options.sessionId,
+      turnId: options.turnId,
+      cwd: options.cwd,
+      abort: options.abort,
+      phase: options.phase,
+      removedMessages,
+      keptMessages,
+      logger: log
+    });
+    return {
+      compacted: true,
+      messages: persistedMessages2,
+      persistedMessages: persistedMessages2,
+      decision,
+      effectiveness: createCompactionEffectiveness(tokensBefore, tokensAfter2),
+      displaySummary: false,
+      storageSummary: "Conversation history was compacted without a summary.",
+      removedCount,
+      tokensRemoved: Math.max(0, tokensBefore - tokensAfter2),
+      summarized: false,
+      summary: void 0,
+      cutIndex,
+      cutReason,
+      tokensBefore,
+      tokensAfter: tokensAfter2,
+      limit
+    };
   }
-  return new Set(Array.isArray(status) ? status : [status]);
+  const summaryText = summary ?? buildFallbackCompactionSummary(removedMessages);
+  const persistedMessages = [...preservedContextFragments, ...keptMessages];
+  const summaryMessage = {
+    id: crypto.randomUUID(),
+    role: "system",
+    content: createCompactionSummaryContent(summaryText),
+    createdAt: /* @__PURE__ */ new Date()
+  };
+  const messagesWithSummary = [
+    summaryMessage,
+    ...preservedContextFragments,
+    ...keptMessages
+  ];
+  const tokensAfter = estimateConversationTokens(messagesWithSummary);
+  await prepareMemoryForCompaction({
+    provider: options.memoryProvider,
+    sessionId: options.sessionId,
+    turnId: options.turnId,
+    cwd: options.cwd,
+    abort: options.abort,
+    phase: options.phase,
+    removedMessages,
+    keptMessages,
+    summary: summaryText,
+    logger: log
+  });
+  return {
+    compacted: true,
+    messages: messagesWithSummary,
+    persistedMessages,
+    decision,
+    effectiveness: createCompactionEffectiveness(tokensBefore, tokensAfter),
+    displaySummary: true,
+    storageSummary: summaryText,
+    removedCount,
+    tokensRemoved: Math.max(0, tokensBefore - tokensAfter),
+    summarized,
+    summary: summaryText,
+    cutIndex,
+    cutReason,
+    tokensBefore,
+    tokensAfter,
+    limit
+  };
 }
-function inferKind(input) {
-  if (input.kind) {
-    return input.kind;
+async function compactAgentContext(options) {
+  const result = await compactAgentMessages({
+    contextManager: options.contextManager,
+    messages: getVisibleSessionMessages(options.sessions),
+    logger: options.logger,
+    force: options.force,
+    memoryProvider: options.memoryProvider,
+    sessionId: options.sessionId ?? options.sessions.getSessionId() ?? void 0,
+    turnId: options.turnId,
+    cwd: options.cwd ?? options.sessions.getHeader()?.cwd,
+    abort: options.abort,
+    phase: options.phase,
+    transientContextTokens: options.transientContextTokens
+  });
+  if (result.compacted) {
+    await options.sessions.replaceWithCompaction({
+      summary: result.storageSummary,
+      displaySummary: result.displaySummary,
+      messages: result.persistedMessages,
+      tokensBefore: result.tokensBefore,
+      tokensAfter: result.tokensAfter
+    });
   }
-  if (input.options && input.options.length > 0) {
-    return "choice";
-  }
-  return "text";
-}
-function isHumanInputController(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.request === "function" && typeof candidate.respondToRequest === "function" && typeof candidate.getRequest === "function" && typeof candidate.listRequests === "function" && typeof candidate.cancelAll === "function";
-}
-async function emitHumanInputEvent(context, event) {
-  await context?.emitEvent?.(event);
+  return {
+    removedCount: result.removedCount,
+    decision: result.decision,
+    effectiveness: result.effectiveness,
+    tokensRemoved: result.tokensRemoved,
+    summarized: result.summarized,
+    summary: result.summary,
+    cutIndex: result.cutIndex,
+    cutReason: result.cutReason
+  };
 }
-function createHumanInputController(config = {}) {
-  const timeout = config.timeout ?? 5 * 60 * 1e3;
-  let requestCounter = 0;
-  const pending = /* @__PURE__ */ new Map();
-  async function request(sessionId, input, context = {}) {
-    const requestPayload = {
-      id: `human-input-${++requestCounter}-${Date.now()}`,
-      sessionId,
-      kind: inferKind(input),
-      title: input.title,
-      question: input.question,
-      ...input.options ? { options: input.options.map((option) => ({ ...option })) } : {},
-      ...input.allowMultiple !== void 0 ? { allowMultiple: input.allowMultiple } : {},
-      ...input.placeholder ? { placeholder: input.placeholder } : {},
-      ...input.confirmLabel ? { confirmLabel: input.confirmLabel } : {},
-      ...input.denyLabel ? { denyLabel: input.denyLabel } : {},
-      ...input.toolCallId ? { toolCallId: input.toolCallId } : {},
-      timestamp: Date.now()
-    };
-    const record = {
-      id: requestPayload.id,
-      sessionId,
-      request: structuredClone(requestPayload),
-      status: "pending",
-      createdAt: requestPayload.timestamp,
-      updatedAt: requestPayload.timestamp
-    };
-    const responsePromise = new Promise(
-      (resolve2, reject) => {
-        const timeoutId = setTimeout(() => {
-          const current2 = pending.get(record.id);
-          if (!current2) {
-            return;
-          }
-          pending.delete(record.id);
-          current2.record = {
-            ...current2.record,
-            status: "timed-out",
-            updatedAt: Date.now()
-          };
-          void emitHumanInputEvent(
-            { emitEvent: current2.emitEvent },
-            { type: "status", status: "processing" }
-          );
-          reject(new HumanInputTimeoutError(timeout));
-        }, timeout);
-        pending.set(record.id, {
-          record,
-          resolve: resolve2,
-          reject,
-          ready: Promise.resolve(),
-          timeoutId,
-          emitEvent: context.emitEvent
-        });
+
+// src/agent/turn-context/compaction/check.ts
+async function runCompactionCheck(params) {
+  const {
+    contextManager,
+    sessions,
+    logger,
+    force = false,
+    phase,
+    sessionId,
+    turnId,
+    cwd,
+    abort,
+    memoryProvider,
+    retryAttempt,
+    transientContextTokens
+  } = params;
+  const messages = sessions.getMessages();
+  const limits = contextManager.getLimits();
+  const transientTokens = Number.isFinite(transientContextTokens) && transientContextTokens ? Math.max(0, Math.floor(transientContextTokens)) : 0;
+  const inputTokens = estimateConversationTokens(messages) + transientTokens;
+  const limit = getUsableTokenLimit(limits);
+  const decision = contextManager.decide(messages, {
+    force,
+    inputTokens
+  });
+  if (!force && !decision.needed) {
+    return {
+      events: [],
+      compacted: false,
+      inputTokens,
+      limit,
+      report: {
+        applied: false,
+        phase,
+        inputTokens,
+        limit,
+        decision,
+        effectiveness: createCompactionEffectiveness(inputTokens, inputTokens),
+        removedCount: 0,
+        tokensRemoved: 0,
+        summarized: false
       }
-    );
-    const current = pending.get(record.id);
-    if (current) {
-      current.ready = (async () => {
-        await emitHumanInputEvent(context, {
-          type: "status",
-          status: "waiting-input"
-        });
-        await emitHumanInputEvent(context, {
-          type: "human-input-request",
-          request: {
-            id: requestPayload.id,
-            kind: requestPayload.kind,
-            title: requestPayload.title,
-            question: requestPayload.question,
-            ...requestPayload.options ? { options: requestPayload.options } : {},
-            ...requestPayload.allowMultiple !== void 0 ? { allowMultiple: requestPayload.allowMultiple } : {},
-            ...requestPayload.placeholder ? { placeholder: requestPayload.placeholder } : {},
-            ...requestPayload.confirmLabel ? { confirmLabel: requestPayload.confirmLabel } : {},
-            ...requestPayload.denyLabel ? { denyLabel: requestPayload.denyLabel } : {}
-          }
-        });
-      })();
-    }
-    if (config.onRequest) {
-      void (async () => {
-        try {
-          await pending.get(record.id)?.ready;
-          const response = await config.onRequest(requestPayload);
-          await respondToRequest(record.id, response, context);
-        } catch (error) {
-          if (error instanceof HumanInputTimeoutError) {
-            return;
-          }
-          const current2 = pending.get(record.id);
-          if (!current2) {
-            return;
-          }
-          pending.delete(record.id);
-          clearTimeout(current2.timeoutId);
-          current2.record = {
-            ...current2.record,
-            status: "cancelled",
-            updatedAt: Date.now()
-          };
-          current2.reject(
-            error instanceof Error ? error : new Error(String(error))
-          );
-          await emitHumanInputEvent(
-            { emitEvent: current2.emitEvent },
-            { type: "status", status: "processing" }
-          );
-        }
-      })();
-    }
-    return await responsePromise;
-  }
-  async function respondToRequest(requestId, response, context = {}) {
-    const current = pending.get(requestId);
-    if (!current) {
-      throw new Error(`Human input request not found: ${requestId}`);
-    }
-    await current.ready;
-    pending.delete(requestId);
-    clearTimeout(current.timeoutId);
-    const respondedAt = Date.now();
-    const next = {
-      ...current.record,
-      status: "answered",
-      updatedAt: respondedAt,
-      respondedAt,
-      response: structuredClone(response)
     };
-    current.resolve(response);
-    const emitEvent = context.emitEvent ?? current.emitEvent;
-    await emitHumanInputEvent(
-      { emitEvent },
-      {
-        type: "human-input-resolved",
-        id: requestId,
-        response
-      }
-    );
-    await emitHumanInputEvent(
-      { emitEvent },
-      { type: "status", status: "processing" }
-    );
-    return cloneRecord(next);
-  }
-  function getRequest(requestId) {
-    const current = pending.get(requestId);
-    return current ? cloneRecord(current.record) : void 0;
-  }
-  function listRequests(options = {}) {
-    const statuses = normalizeStatuses(options.status);
-    return [...pending.values()].map((entry) => cloneRecord(entry.record)).filter((record) => {
-      if (options.sessionId && record.sessionId !== options.sessionId) {
-        return false;
-      }
-      if (statuses && !statuses.has(record.status)) {
-        return false;
-      }
-      return true;
-    }).sort((left, right) => left.createdAt - right.createdAt);
   }
-  function cancelAll(reason = "Cancelled") {
-    for (const [requestId, current] of pending) {
-      pending.delete(requestId);
-      clearTimeout(current.timeoutId);
-      current.record = {
-        ...current.record,
-        status: "cancelled",
-        updatedAt: Date.now()
+  const events = [{ type: "status", status: "processing" }];
+  try {
+    const pruneResult = await compactAgentContext({
+      contextManager,
+      sessions,
+      logger,
+      force,
+      sessionId,
+      turnId,
+      cwd,
+      abort,
+      memoryProvider,
+      phase,
+      transientContextTokens: transientTokens
+    });
+    if (pruneResult.removedCount > 0 || pruneResult.summarized || pruneResult.tokensRemoved > 0) {
+      events.push({
+        type: "context-compaction",
+        phase,
+        inputTokens,
+        limit,
+        decision: pruneResult.decision,
+        effectiveness: pruneResult.effectiveness,
+        removedCount: pruneResult.removedCount,
+        tokensRemoved: pruneResult.tokensRemoved,
+        summarized: pruneResult.summarized,
+        ...pruneResult.cutReason ? { cutReason: pruneResult.cutReason } : {},
+        ...retryAttempt !== void 0 ? { retryAttempt } : {}
+      });
+      events.push({
+        type: "context-overflow",
+        inputTokens,
+        limit
+      });
+      return {
+        events,
+        compacted: true,
+        inputTokens,
+        limit,
+        report: {
+          applied: true,
+          phase,
+          inputTokens,
+          limit,
+          decision: pruneResult.decision,
+          effectiveness: pruneResult.effectiveness,
+          removedCount: pruneResult.removedCount,
+          tokensRemoved: pruneResult.tokensRemoved,
+          summarized: pruneResult.summarized,
+          ...pruneResult.cutIndex !== void 0 ? { cutIndex: pruneResult.cutIndex } : {},
+          ...pruneResult.cutReason ? { cutReason: pruneResult.cutReason } : {}
+        }
       };
-      current.reject(new Error(reason));
-      void emitHumanInputEvent(
-        { emitEvent: current.emitEvent },
-        { type: "status", status: "processing" }
-      );
     }
+  } catch (error) {
+    logger?.warn("Context compaction failed, continuing without compaction", {
+      error: error instanceof Error ? error.message : String(error),
+      phase
+    });
   }
   return {
-    get hasPendingRequests() {
-      return pending.size > 0;
-    },
-    request,
-    respondToRequest,
-    getRequest,
-    listRequests,
-    cancelAll
+    events,
+    compacted: false,
+    inputTokens,
+    limit,
+    report: {
+      applied: false,
+      phase,
+      inputTokens,
+      limit,
+      decision,
+      effectiveness: createCompactionEffectiveness(inputTokens, inputTokens),
+      removedCount: 0,
+      tokensRemoved: 0,
+      summarized: false
+    }
   };
 }
-
-// src/human/handler.ts
-function createHumanInputHandler(config = {}) {
-  return createHumanInputController(config);
+async function runAutoCompaction(params) {
+  const result = await runCompactionCheck({
+    ...params,
+    phase: "post-turn"
+  });
+  return result.events;
 }
 
-// src/human/tool.ts
-import { z } from "zod";
-function createHumanInputTool(options = {}) {
-  if (options.controller) {
-    return createHumanInputToolWithController(options.controller, options);
+// src/agent/turn-context/fit-model-context.ts
+function resolveConfiguredFragmentBudget(context) {
+  const maxEstimatedTokens = context?.maxEstimatedFragmentTokens;
+  if (maxEstimatedTokens === void 0 || !Number.isFinite(maxEstimatedTokens)) {
+    return void 0;
   }
-  if (options.onRequest || options.timeout !== void 0) {
-    return createHumanInputToolWithController(
-      createHumanInputController(options),
-      options
+  return {
+    maxEstimatedTokens: Math.max(0, Math.floor(maxEstimatedTokens))
+  };
+}
+async function assembleChatModelContextToFit(params) {
+  let compactionReport = params.compactionReport;
+  const events = [];
+  let assembledContext;
+  const contextFragmentBudget = resolveConfiguredFragmentBudget(params.context);
+  for (let attempt = 0; ; attempt++) {
+    assembledContext = await assembleModelContext({
+      sessionId: params.sessionId,
+      turnId: params.turnId,
+      step: params.step,
+      cwd: params.cwd,
+      messages: params.sessions.getMessages(),
+      toolNames: params.toolNames,
+      mcpToolNames: params.mcpToolNames,
+      ...params.abort ? { abort: params.abort } : {},
+      contextFragmentCollector: params.middlewareRunner,
+      window: params.contextManager,
+      ...contextFragmentBudget ? { contextFragmentBudget } : {},
+      ...compactionReport ? { compaction: compactionReport } : {}
+    });
+    const windowBefore = assembledContext.report.window.before;
+    const windowAfter = assembledContext.report.window.after;
+    if (!params.fitAssembledContext || attempt > 0 || !windowAfter?.shouldPrune) {
+      break;
+    }
+    const transientContextTokens = Math.max(
+      0,
+      windowAfter.tokens - (windowBefore?.tokens ?? 0)
     );
+    const compaction = await runCompactionCheck({
+      contextManager: params.contextManager,
+      sessions: params.sessions,
+      logger: params.logger,
+      force: true,
+      phase: "pre-step",
+      sessionId: params.sessionId,
+      turnId: params.turnId,
+      cwd: params.cwd,
+      ...params.abort ? { abort: params.abort } : {},
+      memoryProvider: params.memoryProvider,
+      transientContextTokens
+    });
+    events.push(...compaction.events);
+    if (!compaction.compacted) {
+      break;
+    }
+    compactionReport = compaction.report;
   }
-  return createHumanInputToolWithController(void 0, options);
+  return { assembledContext, events };
 }
-function createHumanInputToolWithController(controller, options = {}) {
-  return Tool.define(
-    options.name ?? "question",
-    {
-      description: options.description ?? "Ask a human for missing input, a decision, a confirmation, or a choice.",
-      parameters: z.object({
-        title: z.string().min(1).describe("Short heading for the request"),
-        question: z.string().min(1).describe("What to ask the human"),
-        kind: z.enum(["text", "confirm", "choice"]).optional(),
-        options: z.array(
-          z.object({
-            label: z.string().min(1),
-            value: z.string().optional(),
-            description: z.string().optional()
-          })
-        ).optional(),
-        allowMultiple: z.boolean().optional(),
-        placeholder: z.string().optional(),
-        confirmLabel: z.string().optional(),
-        denyLabel: z.string().optional()
-      }),
-      validate: (params) => {
-        const kind = params.kind ?? (params.options?.length ? "choice" : "text");
-        if (kind === "choice" && (!params.options || params.options.length === 0)) {
-          return {
-            ok: false,
-            reason: "Choice requests must include at least one option."
-          };
+
+// src/agent/turn-context/system-prompts.ts
+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;
+}
+
+// src/agent/setup/runtime-config.ts
+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 } : {},
+    ...options.reserveTokens !== void 0 ? { reserveTokens: options.reserveTokens } : {},
+    ...config.streamProvider ? { streamProvider: config.streamProvider } : {},
+    ...telemetrySettings ? { telemetry: telemetrySettings } : {}
+  };
+}
+
+// src/agent/instance/sessions.ts
+function createAgentSessionManager(sessions) {
+  return new SessionManager(sessions.getStorage());
+}
+async function acquireAgentSessionLock(lock, sessionId, options) {
+  return await lock.acquire(sessionId, options);
+}
+async function syncAgentSessionView(options) {
+  const { sessions, sessionId } = options;
+  if (!await sessions.sessionExists(sessionId)) {
+    return;
+  }
+  await sessions.load(sessionId);
+}
+
+// src/agent/instance/interventions.ts
+function getActiveAgentInterventionController(activeTurns) {
+  const active = Array.from(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;
+}
+function getAgentInterventionControllerForTurn(activeTurns, fallback) {
+  return getActiveAgentInterventionController(activeTurns) ?? fallback;
+}
+function createAgentTurnInterventionController(activeTurns, fallback) {
+  return activeTurns.size === 0 ? fallback : new InterventionController();
+}
+function releaseAgentTurnInterventions(fallback, controller) {
+  if (controller === fallback) {
+    controller.resetCallbacks();
+    return;
+  }
+  fallback.adoptImmediate(controller.drainImmediate());
+  fallback.adoptDeferred(controller.drainDeferred());
+  controller.resetCallbacks();
+}
+
+// src/agent/instance/mcp.ts
+async function ensureAgentMcpTools(state, logger) {
+  if (!state.manager) {
+    return { connected: false, cachedTools: void 0 };
+  }
+  if (state.connected && state.cachedTools) {
+    return {
+      connected: state.connected,
+      cachedTools: state.cachedTools
+    };
+  }
+  const log = logger.child("mcp");
+  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") {
+      log.warn(`Failed to connect to ${name}: ${status.error}`);
+    }
+  }
+  if (connectedCount === 0 && statuses.size > 0) {
+    log.warn("No MCP servers connected successfully");
+  }
+  const cachedTools = await state.manager.getTools();
+  return {
+    connected: true,
+    cachedTools
+  };
+}
+async function reconnectAgentMcp(state, logger) {
+  if (!state.manager) {
+    return { connected: false, cachedTools: void 0 };
+  }
+  await state.manager.close();
+  return await ensureAgentMcpTools(
+    {
+      manager: state.manager,
+      connected: false,
+      cachedTools: void 0
+    },
+    logger
+  );
+}
+async function closeAgentMcp(manager) {
+  if (manager) {
+    await manager.close();
+  }
+  return {
+    connected: false,
+    cachedTools: void 0
+  };
+}
+
+// src/agent/instance/context-management.ts
+function getAgentContextStats(options) {
+  return options.contextManager.getStats(options.sessions.getMessages());
+}
+async function compactLoadedAgentContext(options) {
+  return await compactAgentContext(options);
+}
+async function compactAgentMessageList(options) {
+  return await compactAgentMessages(options);
+}
+
+// src/agent/instance/tools.ts
+async function ensureAgentSkillTools(options) {
+  if (options.resolved || !options.promptBuilder) {
+    return options.resolved;
+  }
+  const registry = await options.promptBuilder.getSkillRegistry(options.cwd);
+  for (const tool of createSkillTools(registry)) {
+    if (!options.tools.has(tool.id)) {
+      options.tools.set(tool.id, tool);
+    }
+  }
+  return true;
+}
+function resetPromptScopedTools(tools) {
+  tools.delete("skill");
+  tools.delete("skill_resource");
+}
+function addAgentTool(tools, tool) {
+  tools.set(tool.id, tool);
+}
+function removeAgentTool(tools, toolId) {
+  return tools.delete(toolId);
+}
+function getAgentToolIds(tools) {
+  return Array.from(tools.keys());
+}
+function getAgentTools(tools) {
+  return Array.from(tools.values());
+}
+function hasAgentTool(tools, toolId) {
+  return tools.has(toolId);
+}
+function hasAgentHumanInputTools(tools) {
+  return [...tools.values()].some(
+    (tool) => tool.capabilitiesHint?.humanInput === true
+  );
+}
+
+// src/agent/fork.ts
+function resolveForkOptions(options, parentTools, systemPrompt) {
+  if (!options.profile) {
+    return options;
+  }
+  const applied = applyProfile(options.profile, parentTools, systemPrompt);
+  return {
+    ...applied,
+    ...options,
+    tools: options.tools ?? applied.tools
+  };
+}
+function resolveChildPromptConfig(options) {
+  const { forkOptions, promptBuilder, parentPromptConfig, parentSystemPrompt } = options;
+  if (forkOptions.systemPrompt) {
+    return { systemPrompt: forkOptions.systemPrompt };
+  }
+  if (forkOptions.prompt) {
+    return { prompt: forkOptions.prompt };
+  }
+  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,
+    sandbox,
+    humanInputController,
+    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 ? {} : sandbox !== void 0 ? { sandbox } : { host },
+    ...humanInputController ? { humanInput: humanInputController } : {},
+    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,
+    memory: parentConfig.memory,
+    mcp: mcpManager,
+    turnToolProviders: forkOptions.turnToolProviders ?? parentConfig.turnToolProviders,
+    middleware: resolveForkMiddleware(forkOptions, middlewareRunner)
+  };
+}
+
+// src/agent/instance/forking.ts
+function createSubAgentConfig(options) {
+  const effectiveOptions = resolveForkOptions(
+    options.forkOptions,
+    options.parentTools,
+    options.parentConfig.systemPrompt
+  );
+  return createForkedAgentConfig({
+    forkOptions: effectiveOptions,
+    parentConfig: options.parentConfig,
+    parentTools: options.parentTools,
+    reasoningLevel: options.reasoningLevel,
+    host: options.host,
+    sandbox: options.sandbox,
+    humanInputController: options.humanInputController,
+    ownsHost: options.ownsHost,
+    sessions: options.sessions,
+    mcpManager: options.mcpManager,
+    middlewareRunner: options.middlewareRunner,
+    promptBuilder: options.promptBuilder
+  });
+}
+
+// src/agent/chat-loop/commit-batch.ts
+function createChatLoopCommitBatchApplier(params) {
+  const { turnEngine, sessions, middlewareRunner } = params;
+  return async function* applyCommitBatch(batch, options = {}) {
+    turnEngine.recordEvent(batch.startBoundary, (/* @__PURE__ */ new Date()).toISOString());
+    middlewareRunner.emitEvent(batch.startBoundary);
+    yield batch.startBoundary;
+    await sessions.addMessages(batch.messages);
+    turnEngine.recordEvent(batch.finishBoundary, (/* @__PURE__ */ new Date()).toISOString());
+    middlewareRunner.emitEvent(batch.finishBoundary);
+    yield batch.finishBoundary;
+    if (options.emitMessages) {
+      for (const committedMessage of batch.messages) {
+        yield { type: "message", message: committedMessage };
+      }
+    }
+  };
+}
+
+// src/agent/chat-loop/context-recovery.ts
+var DEFAULT_CONTEXT_RECOVERY_RETRIES = 2;
+function resolveContextRecoveryConfig(compaction) {
+  const recovery = compaction?.recovery;
+  const enabled = recovery?.enabled ?? compaction?.autoContinue ?? compaction?.auto !== false;
+  const compactBeforeStep = recovery?.compactBeforeStep ?? true;
+  const configuredRetries = recovery?.maxRetries ?? DEFAULT_CONTEXT_RECOVERY_RETRIES;
+  return {
+    enabled,
+    compactBeforeStep,
+    maxRetries: Math.max(0, Math.floor(configuredRetries))
+  };
+}
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === "object" && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return String(error);
+}
+function isContextOverflowError(error) {
+  if (error instanceof LLMError) {
+    return error.category === "context_overflow";
+  }
+  if (error instanceof Error && error.name === "ContextOverflowError") {
+    return true;
+  }
+  const lowerMessage = errorMessage(error).toLowerCase();
+  return lowerMessage.includes("context") && (lowerMessage.includes("length") || lowerMessage.includes("window") || lowerMessage.includes("overflow")) || lowerMessage.includes("input") && lowerMessage.includes("token") && lowerMessage.includes("exceed");
+}
+async function runContextRecoveryCompaction(params) {
+  return await runCompactionCheck(params);
+}
+
+// src/agent/chat-loop/turn-tools.ts
+async function resolveTurnTools(options) {
+  const tools = /* @__PURE__ */ new Map();
+  const mcpTools = {};
+  const cleanup = [];
+  try {
+    for (const provider of options.providers) {
+      const resolved = await provider.resolveTools(options.context);
+      if (resolved.cleanup) {
+        cleanup.push(resolved.cleanup);
+      }
+      for (const tool of resolved.tools ?? []) {
+        if (options.baseTools.has(tool.id) || tools.has(tool.id)) {
+          throw new Error(
+            `Turn tool provider "${provider.name}" returned duplicate tool "${tool.id}"`
+          );
+        }
+        tools.set(tool.id, tool);
+      }
+      for (const [name, tool] of Object.entries(resolved.mcpTools ?? {})) {
+        if (options.baseMcpTools[name] || mcpTools[name]) {
+          throw new Error(
+            `Turn tool provider "${provider.name}" returned duplicate MCP tool "${name}"`
+          );
+        }
+        mcpTools[name] = tool;
+      }
+    }
+  } catch (error) {
+    try {
+      await cleanupTurnTools(cleanup);
+    } catch {
+    }
+    throw error;
+  }
+  return { tools, mcpTools, cleanup };
+}
+function mergeTurnTools(baseTools, turnTools) {
+  if (turnTools.size === 0) {
+    return baseTools;
+  }
+  const merged = new Map(baseTools);
+  for (const [id, tool] of turnTools) {
+    if (merged.has(id)) {
+      throw new Error(`Turn-scoped tool "${id}" conflicts with an agent tool`);
+    }
+    merged.set(id, tool);
+  }
+  return merged;
+}
+async function cleanupTurnTools(cleanup) {
+  const errors = [];
+  for (const cleanupFn of [...cleanup].reverse()) {
+    try {
+      await cleanupFn();
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  if (errors.length === 1) {
+    throw errors[0];
+  }
+  if (errors.length > 1) {
+    throw new AggregateError(
+      errors,
+      "Multiple turn tool cleanup callbacks failed"
+    );
+  }
+}
+
+// src/agent/chat-loop/model-step-snapshot.ts
+function createChatModelStepToolRecord(params) {
+  return createAgentToolRecord(
+    mergeTurnTools(params.liveTools, params.resolvedTurnTools.tools)
+  );
+}
+function createAgentToolRecord(tools) {
+  const toolRecord = {};
+  for (const [id, tool] of tools) {
+    toolRecord[id] = tool;
+  }
+  return toolRecord;
+}
+async function createChatModelStepSnapshot(params) {
+  const tools = createChatModelStepToolRecord({
+    liveTools: params.liveTools,
+    resolvedTurnTools: params.resolvedTurnTools
+  });
+  const systemPrompts = await buildAgentSystemPrompts({
+    config: params.config,
+    toolIds: Object.keys(tools),
+    sessionId: params.sessionId,
+    override: params.systemOverride,
+    promptBuilder: params.promptBuilder,
+    middlewareRunner: params.middlewareRunner
+  });
+  const { assembledContext, events } = await assembleChatModelContextToFit({
+    sessionId: params.sessionId,
+    turnId: params.turnId,
+    step: params.step,
+    cwd: params.config.cwd,
+    sessions: params.sessions,
+    toolNames: Object.keys(tools),
+    mcpToolNames: Object.keys(params.mcpTools),
+    middlewareRunner: params.middlewareRunner,
+    contextManager: params.contextManager,
+    ...params.compactionReport ? { compactionReport: params.compactionReport } : {},
+    fitAssembledContext: params.fitAssembledContext,
+    context: params.config.context,
+    ...params.abort ? { abort: params.abort } : {},
+    ...params.logger ? { logger: params.logger } : {},
+    ...params.memoryProvider ? { memoryProvider: params.memoryProvider } : {}
+  });
+  return {
+    sessionId: params.sessionId,
+    turnId: params.turnId,
+    step: params.step,
+    systemPrompts,
+    messages: assembledContext.messages,
+    contextReport: assembledContext.report,
+    tools,
+    mcpTools: { ...params.mcpTools },
+    events
+  };
+}
+
+// src/agent/chat-loop/model-step-runner.ts
+async function* runChatModelStepWithRecovery(options) {
+  const { deps, contextRecovery } = options;
+  const {
+    sessionId,
+    turnId,
+    abort,
+    systemOverride,
+    sessions,
+    tools: liveTools,
+    config,
+    turnTracker,
+    interventionCtrl,
+    middlewareRunner,
+    contextManager,
+    rememberedDoomLoopTools,
+    reasoningLevel,
+    promptBuilder,
+    host,
+    humanInputController,
+    toModelMessages
+  } = deps;
+  let stepResult;
+  let contextRecoveryAttempts = 0;
+  let latestCompactionReport = options.compactionReport;
+  let toolRecord = options.toolRecord;
+  while (!stepResult) {
+    const stepSnapshot = await createChatModelStepSnapshot({
+      sessionId,
+      turnId,
+      step: options.step,
+      sessions,
+      liveTools,
+      resolvedTurnTools: options.resolvedTurnTools,
+      mcpTools: options.turnMcpTools,
+      promptBuilder,
+      middlewareRunner,
+      contextManager,
+      ...latestCompactionReport ? { compactionReport: latestCompactionReport } : {},
+      fitAssembledContext: contextRecovery.enabled && contextRecovery.compactBeforeStep,
+      ...deps.logger ? { logger: deps.logger } : {},
+      ...deps.memoryProvider ? { memoryProvider: deps.memoryProvider } : {},
+      systemOverride,
+      config,
+      abort
+    });
+    toolRecord = stepSnapshot.tools;
+    for (const event of stepSnapshot.events) {
+      middlewareRunner.emitEvent(event);
+      yield event;
+    }
+    const preparedStep = prepareModelStep({
+      sessionId: stepSnapshot.sessionId,
+      turnId: stepSnapshot.turnId,
+      step: stepSnapshot.step,
+      systemPrompts: stepSnapshot.systemPrompts,
+      messages: stepSnapshot.messages,
+      contextReport: stepSnapshot.contextReport,
+      toModelMessages,
+      abort,
+      tools: stepSnapshot.tools,
+      mcpTools: stepSnapshot.mcpTools,
+      config,
+      host,
+      humanInputController,
+      turnTracker,
+      intervention: interventionCtrl,
+      middleware: middlewareRunner,
+      reasoningLevel,
+      toolExecutionMode: deps.toolExecutionMode
+    });
+    try {
+      stepResult = yield* runModelStep({
+        preparedStep,
+        turnEngine: options.turnEngine,
+        applyCommitBatch: options.applyCommitBatch,
+        rememberedDoomLoopTools,
+        deferErrorEvent: contextRecovery.enabled ? isContextOverflowError : void 0
+      });
+    } catch (error) {
+      const recovery = await maybeRunRecoveryCompaction({
+        error,
+        deps,
+        contextRecovery,
+        contextRecoveryAttempts
+      });
+      if (recovery) {
+        yield* recovery.events;
+        if (recovery.compacted) {
+          contextRecoveryAttempts += 1;
+          latestCompactionReport = recovery.report;
+          continue;
+        }
+      }
+      throw error;
+    }
+    if (stepResult.error) {
+      const recovery = await maybeRunRecoveryCompaction({
+        error: stepResult.error,
+        deps,
+        contextRecovery,
+        contextRecoveryAttempts
+      });
+      if (recovery) {
+        yield* recovery.events;
+        if (recovery.compacted) {
+          contextRecoveryAttempts += 1;
+          latestCompactionReport = recovery.report;
+          stepResult = void 0;
+        }
+      }
+    }
+  }
+  return {
+    stepResult,
+    toolRecord,
+    ...latestCompactionReport ? { compactionReport: latestCompactionReport } : {}
+  };
+}
+async function maybeRunRecoveryCompaction(options) {
+  const { error, deps, contextRecovery, contextRecoveryAttempts } = options;
+  if (!contextRecovery.enabled || !isContextOverflowError(error) || contextRecoveryAttempts >= contextRecovery.maxRetries) {
+    return void 0;
+  }
+  const recoveryCompaction = await runContextRecoveryCompaction({
+    contextManager: deps.contextManager,
+    sessions: deps.sessions,
+    logger: deps.logger,
+    force: true,
+    phase: "recovery",
+    sessionId: deps.sessionId,
+    turnId: deps.turnId,
+    cwd: deps.config.cwd,
+    abort: deps.abort,
+    memoryProvider: deps.memoryProvider,
+    retryAttempt: contextRecoveryAttempts + 1
+  });
+  for (const event of recoveryCompaction.events) {
+    deps.middlewareRunner.emitEvent(event);
+  }
+  return {
+    events: recoveryCompaction.events,
+    report: recoveryCompaction.report,
+    compacted: recoveryCompaction.compacted
+  };
+}
+
+// src/agent/chat-loop/finalize-turn.ts
+async function* finalizeChatLoopTurn(options) {
+  const { deps, turnEngine, applyCommitBatch, turnTracker, text, usage } = options;
+  const {
+    sessionId,
+    turnId,
+    abort,
+    sessions,
+    config,
+    contextManager,
+    middlewareRunner
+  } = deps;
+  yield* commitOutput({
+    text,
+    usage,
+    turnEngine,
+    applyCommitBatch
+  });
+  if (config.compaction?.auto !== false) {
+    const compactionEvents = await runAutoCompaction({
+      contextManager,
+      sessions,
+      logger: deps.logger,
+      sessionId,
+      turnId,
+      cwd: config.cwd,
+      abort,
+      memoryProvider: deps.memoryProvider
+    });
+    for (const event of compactionEvents) {
+      middlewareRunner.emitEvent(event);
+      yield event;
+    }
+  }
+  const turnSummary = await turnTracker.endTurn();
+  if (turnSummary.totalTracked > 0) {
+    yield {
+      type: "turn-summary",
+      turnId: turnSummary.turnId,
+      files: turnSummary.files.map((file) => ({
+        path: file.path,
+        type: file.type,
+        additions: file.additions,
+        deletions: file.deletions
+      })),
+      additions: turnSummary.additions,
+      deletions: turnSummary.deletions
+    };
+  }
+  const output = text || void 0;
+  yield {
+    type: "complete",
+    usage,
+    output
+  };
+  return {
+    ...output !== void 0 ? { output } : {},
+    ...usage !== void 0 ? { usage } : {}
+  };
+}
+
+// src/agent/chat-loop/loop.ts
+async function* runChatLoop(deps) {
+  yield* streamWithinScope(
+    {
+      kind: "turn",
+      name: "agent-turn",
+      sessionId: deps.sessionId
+    },
+    (async function* () {
+      const {
+        sessionId,
+        turnId,
+        message,
+        abort,
+        systemOverride,
+        sessions,
+        tools: liveTools,
+        config,
+        turnTracker,
+        interventionCtrl,
+        middlewareRunner,
+        contextManager,
+        host,
+        humanInputController,
+        mcpTools,
+        setIsStreaming
+      } = deps;
+      let resolvedTurnTools;
+      try {
+        resolvedTurnTools = await resolveTurnTools({
+          providers: deps.turnToolProviders,
+          context: {
+            sessionId,
+            turnId,
+            message,
+            cwd: config.cwd,
+            abort
+          },
+          baseTools: liveTools,
+          baseMcpTools: mcpTools
+        });
+      } catch (error) {
+        const errorInstance = error instanceof Error ? error : new Error(String(error));
+        const statusEvent = { type: "status", status: "error" };
+        middlewareRunner.emitEvent(statusEvent);
+        yield statusEvent;
+        const errorEvent = {
+          type: "error",
+          error: errorInstance
+        };
+        middlewareRunner.emitEvent(errorEvent);
+        yield errorEvent;
+        throw errorInstance;
+      }
+      const turnMcpTools = {
+        ...mcpTools,
+        ...resolvedTurnTools.mcpTools
+      };
+      let toolRecord = createChatModelStepToolRecord({
+        liveTools,
+        resolvedTurnTools
+      });
+      const prevOnApplied = interventionCtrl.onApplied;
+      let streamingStateStarted = false;
+      let chatUsage;
+      let chatError;
+      let chatOutput;
+      let chatEndError;
+      let rethrowError;
+      const lifecycleContext = {
+        sessionId,
+        turnId,
+        history: {
+          getRecentMessages: (options) => sessions.getRecentMessages(options)
         }
-        if (kind !== "choice" && params.allowMultiple) {
-          return {
-            ok: false,
-            reason: "allowMultiple is only valid for choice requests."
-          };
+      };
+      try {
+        const isPlanMode = deps.toolExecutionMode === "plan";
+        const turnEngine = createAgentTurnEngine({
+          sessionId,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          getToolReplayPolicy: (toolName) => toolRecord[toolName] ? normalizeToolReplayPolicy(toolRecord[toolName].replayPolicy) : void 0
+        });
+        const applyCommitBatch = createChatLoopCommitBatchApplier({
+          turnEngine,
+          sessions,
+          middlewareRunner
+        });
+        yield* applyCommitBatch(
+          turnEngine.createInputCommit({
+            content: message,
+            system: systemOverride
+          }),
+          { emitMessages: true }
+        );
+        setIsStreaming(true);
+        streamingStateStarted = true;
+        if (middlewareRunner.hasMiddleware) {
+          await middlewareRunner.runChatStart(
+            sessionId,
+            message,
+            lifecycleContext
+          );
         }
-        return { ok: true };
-      },
-      capabilities: {
-        readOnly: true,
-        riskLevel: "safe",
-        parallelSafe: false,
-        humanInput: true
-      },
-      replayPolicy: {
-        mode: "manual",
-        sideEffectLevel: "external",
-        reason: "Depends on a human response before execution can continue."
-      },
-      execute: async (params, ctx) => {
-        let response;
-        try {
-          const activeController = controller ?? ctx.humanInputController;
-          if (!activeController) {
-            throw new HumanInputUnavailableError();
+        let step = 1;
+        let finalStepText = "";
+        let accumulatedUsage;
+        const contextRecovery = resolveContextRecoveryConfig(config.compaction);
+        let latestContextCompactionReport;
+        while (step <= config.maxSteps) {
+          latestContextCompactionReport = void 0;
+          if (contextRecovery.enabled && contextRecovery.compactBeforeStep) {
+            const preStepCompaction = await runContextRecoveryCompaction({
+              contextManager,
+              sessions,
+              logger: deps.logger,
+              force: false,
+              phase: "pre-step",
+              sessionId,
+              turnId,
+              cwd: config.cwd,
+              abort,
+              memoryProvider: deps.memoryProvider
+            });
+            for (const event of preStepCompaction.events) {
+              middlewareRunner.emitEvent(event);
+              yield event;
+            }
+            latestContextCompactionReport = preStepCompaction.report;
+          }
+          const stepRun = yield* runChatModelStepWithRecovery({
+            deps,
+            step,
+            turnEngine,
+            applyCommitBatch,
+            resolvedTurnTools,
+            turnMcpTools,
+            toolRecord,
+            contextRecovery,
+            ...latestContextCompactionReport ? { compactionReport: latestContextCompactionReport } : {}
+          });
+          const stepResult = stepRun.stepResult;
+          toolRecord = stepRun.toolRecord;
+          latestContextCompactionReport = stepRun.compactionReport;
+          accumulatedUsage = accumulateUsage(
+            accumulatedUsage,
+            stepResult.usage
+          );
+          if (stepResult.error) {
+            chatError = stepResult.error;
+            if (contextRecovery.enabled && isContextOverflowError(stepResult.error)) {
+              const statusEvent = {
+                type: "status",
+                status: "error"
+              };
+              middlewareRunner.emitEvent(statusEvent);
+              yield statusEvent;
+              const errorEvent = {
+                type: "error",
+                error: stepResult.error
+              };
+              middlewareRunner.emitEvent(errorEvent);
+              yield errorEvent;
+            }
+            return;
+          }
+          const planSnapshot = isPlanMode && stepResult.finishReason === "tool-calls" ? turnEngine.createStepCommitSnapshot() : void 0;
+          yield* commitStep({
+            step,
+            finishReason: stepResult.finishReason,
+            turnEngine,
+            applyCommitBatch
+          });
+          if (stepResult.finishReason === "tool-calls") {
+            if (step >= config.maxSteps) {
+              const maxStepsError = new Error(
+                `Maximum steps (${config.maxSteps}) reached before the turn produced a final response`
+              );
+              chatError = maxStepsError;
+              const statusEvent = {
+                type: "status",
+                status: "error"
+              };
+              middlewareRunner.emitEvent(statusEvent);
+              yield statusEvent;
+              const errorEvent = {
+                type: "error",
+                error: maxStepsError
+              };
+              middlewareRunner.emitEvent(errorEvent);
+              yield errorEvent;
+              return;
+            }
+            if (isPlanMode && planSnapshot && planSnapshot.toolCalls.length > 0) {
+              const batchResult = await runToolBatch({
+                sessionId,
+                snapshot: planSnapshot,
+                tools: toolRecord,
+                cwd: config.cwd,
+                abort,
+                host,
+                humanInputController,
+                turnTracker,
+                middleware: middlewareRunner,
+                intervention: interventionCtrl
+              });
+              for (const event of batchResult.events) {
+                turnEngine.recordEvent(event, (/* @__PURE__ */ new Date()).toISOString());
+                middlewareRunner.emitEvent(event);
+                yield event;
+              }
+              yield* commitStep({
+                step,
+                finishReason: "tool-calls",
+                turnEngine,
+                applyCommitBatch
+              });
+            }
+            step += 1;
+            continue;
+          }
+          finalStepText = stepResult.text;
+          break;
+        }
+        const finalization = yield* finalizeChatLoopTurn({
+          deps,
+          turnEngine,
+          applyCommitBatch,
+          turnTracker,
+          text: finalStepText,
+          usage: accumulatedUsage
+        });
+        chatUsage = finalization.usage;
+        chatOutput = finalization.output;
+      } 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;
+        rethrowError = error;
+      } finally {
+        if (streamingStateStarted) {
+          setIsStreaming(false);
+        }
+        interventionCtrl.onApplied = prevOnApplied;
+        if (middlewareRunner.hasMiddleware) {
+          try {
+            await middlewareRunner.runChatEnd(
+              sessionId,
+              {
+                usage: chatUsage,
+                error: chatError,
+                output: chatOutput
+              },
+              lifecycleContext
+            );
+          } catch (error) {
+            chatEndError = error;
           }
-          response = await activeController.request(
-            ctx.sessionID,
-            {
-              ...params,
-              toolCallId: typeof ctx.extra?.toolCallId === "string" ? ctx.extra.toolCallId : ctx.messageID
-            },
-            {
-              emitEvent: ctx.emitEvent
-            }
-          );
+        }
+        try {
+          await cleanupTurnTools(resolvedTurnTools.cleanup);
         } catch (error) {
-          if (error instanceof HumanInputUnavailableError) {
-            throw error;
-          }
-          throw error;
+          const errorInstance = error instanceof Error ? error : new Error(String(error));
+          deps.logger?.warn("Turn tool provider cleanup failed", {
+            error: errorInstance,
+            message: errorInstance.message,
+            stack: errorInstance.stack
+          });
         }
-        return {
-          title: params.title,
-          output: response.text,
-          metadata: { response }
-        };
       }
-    },
-    {
-      replayPolicy: {
-        mode: "manual",
-        sideEffectLevel: "external",
-        reason: "Depends on a human response before execution can continue."
-      },
-      capabilitiesHint: {
-        readOnly: true,
-        riskLevel: "safe",
-        parallelSafe: false,
-        humanInput: true
+      if (chatEndError) {
+        throw chatEndError;
       }
-    }
+      if (rethrowError) {
+        throw rethrowError;
+      }
+    })()
   );
 }
-var createHumanInputToolWithHandler = createHumanInputToolWithController;
-
-// src/agent/stream-provider.ts
-var DEFAULT_CUSTOM_STREAM_MODELS = [
-  "computer-use-preview",
-  "computer-use-preview-2025-03-11"
-];
-function needsCustomStreamProvider(model, customPatterns) {
-  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));
-}
-function hasStreamProviderFactory(tools) {
-  return Array.isArray(tools) && typeof tools.__streamProviderFactory === "function";
-}
-function autoDetectStreamProvider(model, tools, explicitProvider) {
-  if (explicitProvider) {
-    return explicitProvider;
-  }
-  if (!tools) return void 0;
-  const enhancedTools = tools;
-  const customPatterns = enhancedTools.__customStreamModels;
-  if (needsCustomStreamProvider(model, customPatterns) && hasStreamProviderFactory(enhancedTools)) {
-    const modelId = extractModelId(model);
-    if (modelId) {
-      const streamConfig = {
-        apiKey: process.env.OPENAI_API_KEY,
-        display: { width: 1024, height: 768 },
-        environment: "linux",
-        debug: false
-      };
-      return enhancedTools.__streamProviderFactory(modelId, streamConfig);
-    }
-  }
-  return void 0;
-}
 
-// src/agent/setup.ts
-function createAgentPromptBuilder(config) {
-  if (config.prompt !== void 0) {
-    return createPromptBuilder(config.prompt);
-  }
-  if (config.systemPrompt === void 0) {
-    return createPromptBuilder();
-  }
-  return void 0;
-}
-function createEffectiveAgentConfig(config) {
-  const effectiveStreamProvider = autoDetectStreamProvider(
-    config.model,
-    config.tools,
-    config.streamProvider
-  );
-  const resolvedCwd = config.cwd ?? config.sandbox?.metadata?.workingDirectory ?? process.cwd();
-  const defaultsContext = {
-    sandbox: config.sandbox,
-    cwd: resolvedCwd,
-    modelId: extractModelId(config.model)
-  };
-  const providers = [
-    sandboxDefaultsProvider,
-    ...config.defaultsProviders ?? []
-  ];
-  const defaults = resolveAgentDefaults(defaultsContext, providers);
-  return {
-    ...config,
-    systemPrompt: config.systemPrompt ?? defaults.systemPrompt,
-    cwd: resolvedCwd,
-    reasoningLevel: config.reasoningLevel ?? "off",
-    maxSteps: config.maxSteps ?? defaults.maxSteps,
-    maxOutputTokens: config.maxOutputTokens ?? defaults.maxOutputTokens,
-    streamProvider: effectiveStreamProvider
-  };
-}
-function createToolMap(tools) {
-  const toolMap = /* @__PURE__ */ new Map();
-  for (const tool of tools ?? []) {
-    toolMap.set(tool.id, tool);
-  }
-  return toolMap;
-}
-function resolveInitialReasoningLevel(config) {
-  const reasoningConfig = getReasoningConfigSync(config.model);
-  const requestedLevel = config.reasoningLevel ?? "off";
-  return reasoningConfig.availableLevels.includes(requestedLevel) ? requestedLevel : reasoningConfig.availableLevels[0];
-}
-function createAgentState(config) {
-  return {
-    model: config.model,
-    reasoningLevel: resolveInitialReasoningLevel(config)
-  };
-}
-function createAgentContextManager(config) {
-  const compactionConfig = config.compaction ?? {};
-  const modelId = extractModelId(config.model);
-  const inferredWindow = inferContextWindow(modelId);
-  const contextWindow = config.contextWindow ?? inferredWindow ?? DEFAULT_CONTEXT_LIMITS.contextWindow;
-  return new ContextManager({
-    limits: {
-      contextWindow,
-      ...resolveAgentContextLimits(contextWindow, compactionConfig)
-    },
-    model: compactionConfig.summaryModel ?? config.model,
-    summaryPrompt: compactionConfig.summaryPrompt
+// src/agent/instance/turn-lifecycle.ts
+async function* runAgentChatTurn(params) {
+  const { runtime, sessionId, turnId, message, options } = params;
+  const releaseSessionLock = await runtime.acquireSessionLock(sessionId, {
+    signal: options?.abort
   });
-}
-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,
-    getUsableTokenLimit({ 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) {
-  const inputMiddleware = [...input.middleware ?? []];
-  const hasManualApprovalMiddleware = inputMiddleware.some(
-    (mw) => isApprovalMiddleware(mw)
-  );
-  if (input.approval && hasManualApprovalMiddleware) {
-    throw new Error(
-      "createAgent() received both `approval` config and an explicit approval middleware. Use `approval` for the built-in sugar, or install `approvalMiddleware(...)` manually, but not both."
-    );
-  }
-  let effectiveMiddleware = inputMiddleware;
-  let telemetrySettings;
-  let tracingShutdown;
-  if (input.approval) {
-    effectiveMiddleware.push(approvalMiddleware(input.approval));
-  }
-  if (input.tracing) {
-    const agentName = config.name ?? DEFAULT_AGENT_NAME;
-    const telemetryResult = createTelemetryConfig({
-      ...input.tracing,
-      agentName,
-      serviceName: input.tracing.serviceName ?? agentName
+  const sessions = runtime.createSessionManager();
+  let turnTracker;
+  const interventionCtrl = runtime.createTurnInterventionController();
+  let streamingStateActive = false;
+  let turnRegistered = false;
+  try {
+    await runtime.ensureSkillTools();
+    const abort = options?.abort ?? new AbortController().signal;
+    turnTracker = createTurnTracker({ cwd: runtime.config.cwd });
+    runtime.activeTurns.set(turnId, { sessionId, interventionCtrl });
+    turnRegistered = true;
+    await ensureSessionLoaded({
+      sessionId,
+      sessions,
+      cwd: runtime.config.cwd
     });
-    effectiveMiddleware = [
-      ...telemetryResult.middlewares.length > 0 ? telemetryResult.middlewares : [telemetryResult.middleware],
-      ...effectiveMiddleware
-    ];
-    telemetrySettings = telemetryResult.telemetry;
-    tracingShutdown = telemetryResult.shutdown;
-  }
-  return {
-    middlewareRunner: new MiddlewareRunner(effectiveMiddleware, input.logger),
-    ...telemetrySettings ? { telemetrySettings } : {},
-    ...tracingShutdown ? { tracingShutdown } : {}
-  };
-}
-function resolveHumanInputController(input) {
-  if (!input.humanInput) {
-    return {};
-  }
-  return {
-    humanInputController: isHumanInputController(input.humanInput) ? input.humanInput : createHumanInputController(input.humanInput)
-  };
-}
-function resolveExecutionEnvironment(input, config) {
-  if (input.host !== void 0 && input.sandbox !== void 0 && input.host !== input.sandbox.host) {
-    throw new Error(
-      "createAgent() received both `host` and `sandbox`, but `sandbox.host` does not match the provided host. Pass only one execution input, or reuse the same host instance for both."
-    );
-  }
-  if (input.host !== void 0) {
-    return {
-      host: input.host,
-      ...input.sandbox ? { sandbox: input.sandbox } : {},
-      ownsHost: false
-    };
-  }
-  if (input.sandbox !== void 0) {
-    return {
-      host: input.sandbox.host,
-      sandbox: input.sandbox,
-      ownsHost: false
-    };
+    turnTracker.startTurn(turnId);
+    await repairOrphanedToolCalls(sessions);
+    const mcpTools = await runtime.ensureMcpConnected();
+    const loop = runChatLoop({
+      sessionId,
+      turnId,
+      message,
+      abort,
+      systemOverride: options?.system,
+      sessions,
+      tools: runtime.tools,
+      config: runtime.config,
+      turnTracker,
+      interventionCtrl,
+      middlewareRunner: runtime.middlewareRunner,
+      contextManager: runtime.contextManager,
+      rememberedDoomLoopTools: runtime.rememberedDoomLoopTools,
+      reasoningLevel: runtime.reasoningLevel,
+      promptBuilder: runtime.promptBuilder,
+      host: runtime.host,
+      humanInputController: runtime.humanInputController,
+      memoryProvider: runtime.memoryProvider,
+      mcpTools,
+      turnToolProviders: runtime.turnToolProviders,
+      telemetrySettings: runtime.telemetrySettings,
+      toModelMessages: convertAgentMessagesToModelMessages,
+      setIsStreaming: (value) => {
+        if (value === streamingStateActive) return;
+        streamingStateActive = value;
+        runtime.syncStreamingState(value);
+      },
+      toolExecutionMode: runtime.config.toolExecutionMode,
+      logger: runtime.logger
+    });
+    for await (const event of loop) {
+      runtime.signal.emit(event);
+      yield event;
+    }
+  } finally {
+    try {
+      if (streamingStateActive) {
+        runtime.syncStreamingState(false);
+      }
+      if (turnRegistered) {
+        runtime.activeTurns.delete(turnId);
+      }
+      runtime.releaseTurnInterventions(interventionCtrl);
+      if (turnRegistered && turnTracker) {
+        runtime.setTurnTracker(turnTracker);
+      }
+      await runtime.syncSessionView(sessionId);
+    } finally {
+      await releaseSessionLock();
+    }
   }
-  return {
-    host: localHost(config.cwd),
-    ownsHost: true
-  };
 }
-function createAgentSetup(input) {
-  const promptBuilder = createAgentPromptBuilder(input);
-  const config = createEffectiveAgentConfig(input);
-  const middlewareSetup = createMiddlewareSetup(input, config);
-  const humanInputSetup = resolveHumanInputController(input);
-  const executionEnvironment = resolveExecutionEnvironment(input, config);
-  const logger = input.logger ?? silentLogger;
-  return {
-    config,
-    tools: createToolMap(input.tools),
-    sessions: input.sessionManager ?? getDefaultSessionManager(),
-    sessionTurnLock: input.sessionTurnLock ?? new LocalSessionTurnLock(),
-    state: createAgentState(config),
-    contextManager: createAgentContextManager(config),
-    turnTracker: createTurnTracker({ cwd: config.cwd }, logger),
-    ...input.mcp ? { mcpManager: input.mcp } : {},
-    turnToolProviders: [...input.turnToolProviders ?? []],
-    ...promptBuilder ? { promptBuilder } : {},
-    interventionCtrl: new InterventionController(),
-    ...humanInputSetup,
-    ...executionEnvironment,
-    middlewareRunner: middlewareSetup.middlewareRunner,
-    logger,
-    ...middlewareSetup.telemetrySettings ? { telemetrySettings: middlewareSetup.telemetrySettings } : {},
-    ...middlewareSetup.tracingShutdown ? { tracingShutdown: middlewareSetup.tracingShutdown } : {}
-  };
+async function sendAgentMessage(chat, sessionId, message, options) {
+  const events = chat(sessionId, message, options);
+  let response = "";
+  let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  const toolCalls = [];
+  for await (const event of events) {
+    switch (event.type) {
+      case "text-delta":
+        response += event.text;
+        break;
+      case "tool-result":
+        toolCalls.push({ name: event.toolName, result: event.result });
+        break;
+      case "complete":
+        if (event.usage) usage = event.usage;
+        if (event.output !== void 0) response = event.output;
+        break;
+      case "error":
+        throw event.error;
+    }
+  }
+  return { response, usage, toolCalls };
 }
 
-// src/agent/instance.ts
+// src/agent/instance/index.ts
 function createAgent(config) {
   return new Agent(config);
 }
@@ -2194,48 +3241,28 @@ var Agent = class _Agent {
   sessions;
   sessionTurnLock;
   state;
-  /** Context manager for overflow detection and compaction */
   contextManager;
-  /** Tools that user said "remember" for doom loop (don't ask again) */
   rememberedDoomLoopTools = /* @__PURE__ */ new Set();
-  /** Turn change tracker for file modification tracking */
   turnTracker;
-  /** Counter for turn IDs */
   turnCounter = 0;
-  /** MCP manager for external tool servers */
   mcpManager;
   turnToolProviders;
-  /** Whether MCP has been connected (lazy init) */
   mcpConnected = false;
-  /** Whether skill tools have been resolved (lazy init) */
   skillToolsResolved = false;
-  /** Cached MCP tools (refreshed on connect) */
   mcpToolsCache;
-  /** Prompt pipeline builder (when using layered prompt mode) */
   promptBuilder;
-  /** Intervention controller for mid-turn message injection */
   interventionCtrl;
-  /** Execution environment for tool operations */
   host;
-  /** Managed sandbox session, when the agent was created from one */
   sandbox;
-  /** Managed human-input controller for question-style tools */
   humanInputController;
-  /** Whether the agent owns the host and can safely recreate it on cwd changes */
+  memoryProvider;
   ownsHost;
-  /** Middleware runner for lifecycle hooks */
   middlewareRunner;
-  /** AI SDK telemetry settings (auto-created from `tracing` config) */
   telemetrySettings;
-  /** Tracing shutdown function (from `tracing` config auto-setup) */
   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();
-  /** Structured logger for diagnostic output */
   _logger;
   constructor(config) {
     const setup = createAgentSetup(config);
@@ -2253,6 +3280,7 @@ var Agent = class _Agent {
     this.host = setup.host;
     this.sandbox = setup.sandbox;
     this.humanInputController = setup.humanInputController;
+    this.memoryProvider = setup.memoryProvider;
     this.ownsHost = setup.ownsHost;
     this.middlewareRunner = setup.middlewareRunner;
     this._logger = setup.logger;
@@ -2260,142 +3288,83 @@ var Agent = class _Agent {
     this.tracingShutdown = setup.tracingShutdown;
     this._signal = config.signal ?? new LocalSignal();
   }
-  /**
-   * Event signal — subscribe to events without consuming the generator.
-   *
-   * Every event yielded by `chat()` is also dispatched here, allowing
-   * multiple passive observers (SSE routes, TUI, plugins) to listen
-   * concurrently.
-   */
   get signal() {
     return this._signal;
   }
-  /** Structured logger — silent by default, configurable via `createAgent({ logger })`. */
   get logger() {
     return this._logger;
   }
-  /** Agent name (identity for spans, Dapr workflows, etc.) */
   get name() {
     return this.config.name ?? DEFAULT_AGENT_NAME;
   }
-  /** Working directory for file operations */
   get cwd() {
     return this.config.cwd;
   }
-  /** Current model */
   get model() {
     return this.config.model;
   }
-  /** System prompt */
   get systemPrompt() {
     return this.config.systemPrompt;
   }
-  /** Is currently streaming */
   get isStreaming() {
     return this.activeTurnCount > 0;
   }
-  /** Current reasoning level */
   get reasoningLevel() {
     return this.state.reasoningLevel;
   }
-  /**
-   * Set reasoning level
-   * Will be clamped to available levels for the current model
-   */
   setReasoningLevel(level) {
     const config = getReasoningConfigSync(this.state.model);
     const effectiveLevel = config.availableLevels.includes(level) ? level : config.availableLevels[config.availableLevels.length - 1];
     this.state.reasoningLevel = effectiveLevel;
   }
-  /**
-   * Get available reasoning levels for the current model
-   */
   getAvailableReasoningLevels() {
     return getReasoningConfigSync(this.state.model).availableLevels;
   }
-  /**
-   * Check if current model supports reasoning
-   */
   supportsReasoning() {
     return supportsReasoningSync(this.state.model);
   }
-  /**
-   * Ensure skill tools are registered when `prompt.skills` is configured.
-   * Lazy initialization — resolves the registry and adds tools on first use.
-   */
   async ensureSkillTools() {
-    if (this.skillToolsResolved || !this.promptBuilder) return;
-    this.skillToolsResolved = true;
-    const registry = await this.promptBuilder.getSkillRegistry(this.config.cwd);
-    if (registry.size > 0) {
-      for (const tool of createSkillTools(registry)) {
-        if (!this.tools.has(tool.id)) {
-          this.tools.set(tool.id, tool);
-        }
-      }
-    }
+    this.skillToolsResolved = await ensureAgentSkillTools({
+      tools: this.tools,
+      promptBuilder: this.promptBuilder,
+      cwd: this.config.cwd,
+      resolved: this.skillToolsResolved
+    });
   }
   resetPromptScopedTools() {
-    this.tools.delete("skill");
-    this.tools.delete("skill_resource");
+    resetPromptScopedTools(this.tools);
     this.skillToolsResolved = false;
   }
   createSessionManager() {
-    return new SessionManager(this.sessions.getStorage());
+    return createAgentSessionManager(this.sessions);
   }
   async acquireSessionLock(sessionId, options) {
-    return await this.sessionTurnLock.acquire(sessionId, options);
+    return await acquireAgentSessionLock(
+      this.sessionTurnLock,
+      sessionId,
+      options
+    );
   }
-  /**
-   * Force-clear all pending session locks for a given session.
-   *
-   * This is an escape hatch for callers that manage sequencing
-   * externally (e.g. the coordinator loop) and need to guarantee a
-   * prior `chat()` generator's lock won't block the next call — even
-   * if the generator's cleanup is stuck on a network read.
-   *
-   * **Only use when you are certain no concurrent `chat()` calls are
-   * active on this session.**
-   */
   clearSessionLock(sessionId) {
     this.sessionTurnLock.clear?.(sessionId);
   }
-  /**
-   * Acquire the same per-session turn lock used by `chat()`.
-   *
-   * External durable runtimes can hold this lock across a workflow-backed
-   * turn so direct `chat()` calls cannot interleave with the same session.
-   */
   async acquireSessionTurnLock(sessionId) {
     return await this.acquireSessionLock(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;
+    return getAgentInterventionControllerForTurn(
+      this.activeTurns,
+      this.interventionCtrl
+    );
   }
   createTurnInterventionController() {
-    return this.activeTurns.size === 0 ? this.interventionCtrl : new InterventionController();
+    return createAgentTurnInterventionController(
+      this.activeTurns,
+      this.interventionCtrl
+    );
   }
   releaseTurnInterventions(controller) {
-    if (controller === this.interventionCtrl) {
-      controller.resetCallbacks();
-      return;
-    }
-    this.interventionCtrl.adoptImmediate(controller.drainImmediate());
-    this.interventionCtrl.adoptDeferred(controller.drainDeferred());
-    controller.resetCallbacks();
+    releaseAgentTurnInterventions(this.interventionCtrl, controller);
   }
   syncStreamingState(active) {
     this.activeTurnCount = Math.max(
@@ -2404,17 +3373,10 @@ var Agent = class _Agent {
     );
   }
   async syncSessionView(sessionId) {
-    if (!await this.sessions.sessionExists(sessionId)) {
-      return;
-    }
-    await this.sessions.load(sessionId);
+    await syncAgentSessionView({ sessions: this.sessions, sessionId });
   }
-  /**
-   * Ensure MCP is connected and return tools
-   * Lazy initialization - only connects on first use
-   */
   async ensureMCPConnected() {
-    const nextState = await ensureMcpTools(
+    const nextState = await ensureAgentMcpTools(
       {
         manager: this.mcpManager,
         connected: this.mcpConnected,
@@ -2426,184 +3388,87 @@ var Agent = class _Agent {
     this.mcpToolsCache = nextState.cachedTools;
     return nextState.cachedTools ?? {};
   }
-  /**
-   * Stream a chat response.
-   *
-   * Sends a user message and yields real-time {@link AgentEvent}s as the
-   * model responds, calls tools, and finishes. Conversation state is
-   * persisted to the session automatically.
-   *
-   * @param sessionId - Session identifier for conversation history
-   * @param message   - User message to send
-   * @param options   - Abort signal, system prompt override, and approval handler
-   * @yields {AgentEvent} Events as they occur during processing
-   */
   async *chat(sessionId, message, options) {
-    const releaseSessionLock = await this.acquireSessionLock(sessionId, {
-      signal: options?.abort
-    });
-    const sessions = this.createSessionManager();
     const turnId = `${sessionId}-turn-${++this.turnCounter}`;
-    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 repairOrphanedToolCalls(sessions);
-      const mcpTools = await this.ensureMCPConnected();
-      const loop = runChatLoop({
-        sessionId,
-        turnId,
-        message,
-        abort,
-        systemOverride: options?.system,
-        sessions,
-        tools: this.tools,
+    yield* runAgentChatTurn({
+      runtime: {
         config: this.config,
-        turnTracker,
-        interventionCtrl,
-        middlewareRunner: this.middlewareRunner,
+        tools: this.tools,
         contextManager: this.contextManager,
         rememberedDoomLoopTools: this.rememberedDoomLoopTools,
         reasoningLevel: this.state.reasoningLevel,
         promptBuilder: this.promptBuilder,
         host: this.host,
         humanInputController: this.humanInputController,
-        mcpTools,
+        memoryProvider: this.memoryProvider,
         turnToolProviders: this.turnToolProviders,
         telemetrySettings: this.telemetrySettings,
-        toModelMessages: convertAgentMessagesToModelMessages,
-        setIsStreaming: (value) => {
-          if (value === streamingStateActive) return;
-          streamingStateActive = value;
-          this.syncStreamingState(value);
-        },
-        toolExecutionMode: this.config.toolExecutionMode,
-        logger: this._logger
-      });
-      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;
+        middlewareRunner: this.middlewareRunner,
+        signal: this._signal,
+        logger: this._logger,
+        activeTurns: this.activeTurns,
+        acquireSessionLock: (id, lockOptions) => this.acquireSessionLock(id, lockOptions),
+        createSessionManager: () => this.createSessionManager(),
+        ensureSkillTools: () => this.ensureSkillTools(),
+        createTurnInterventionController: () => this.createTurnInterventionController(),
+        releaseTurnInterventions: (controller) => this.releaseTurnInterventions(controller),
+        ensureMcpConnected: () => this.ensureMCPConnected(),
+        syncStreamingState: (active) => this.syncStreamingState(active),
+        syncSessionView: (id) => this.syncSessionView(id),
+        setTurnTracker: (tracker) => {
+          this.turnTracker = tracker;
         }
-        await this.syncSessionView(sessionId);
-      } finally {
-        await releaseSessionLock();
-      }
-    }
+      },
+      sessionId,
+      turnId,
+      message,
+      options
+    });
   }
-  /**
-   * Send a message and wait for the complete response (non-streaming).
-   *
-   * This is a convenience wrapper around {@link chat} that buffers all
-   * events internally and returns the final response, usage, and tool
-   * call results. Prefer `chat()` when you need real-time streaming.
-   *
-   * @param sessionId - Session identifier
-   * @param message   - User message
-   * @param options   - Abort signal and optional system prompt override
-   */
   async send(sessionId, message, options) {
-    const events = this.chat(sessionId, message, options);
-    let response = "";
-    let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-    const toolCalls = [];
-    for await (const event of events) {
-      switch (event.type) {
-        case "text-delta":
-          response += event.text;
-          break;
-        case "tool-result":
-          toolCalls.push({ name: event.toolName, result: event.result });
-          break;
-        case "complete":
-          if (event.usage) usage = event.usage;
-          if (event.output !== void 0) response = event.output;
-          break;
-        case "error":
-          throw event.error;
-      }
-    }
-    return { response, usage, toolCalls };
+    return await sendAgentMessage(
+      (id, text, chatOptions) => this.chat(id, text, chatOptions),
+      sessionId,
+      message,
+      options
+    );
   }
   // ============================================================================
   // Tool Management
   // ============================================================================
-  /** Add a tool at runtime */
   addTool(tool) {
-    this.tools.set(tool.id, tool);
+    addAgentTool(this.tools, tool);
   }
-  /** Remove a tool by ID */
   removeTool(toolId) {
-    return this.tools.delete(toolId);
+    return removeAgentTool(this.tools, toolId);
   }
-  /** Get all tool IDs */
   getToolIds() {
-    return Array.from(this.tools.keys());
+    return getAgentToolIds(this.tools);
   }
-  /** Get all tools */
   getTools() {
-    return Array.from(this.tools.values());
+    return getAgentTools(this.tools);
   }
-  /** Check if a tool exists */
   hasTool(toolId) {
-    return this.tools.has(toolId);
+    return hasAgentTool(this.tools, toolId);
   }
   // ============================================================================
   // Session Management
   // ============================================================================
-  /** Get session manager */
   getSessionManager() {
     return this.sessions;
   }
-  /** Get current session context */
   getSessionContext() {
     return this.sessions.getContext();
   }
-  /**
-   * Get messages from current session.
-   *
-   * NOTE: during an active `chat()` turn, messages are accumulated in a
-   * per-turn SessionManager and synced back after the turn completes.
-   * Calling this mid-turn returns the shared view, which may lag behind
-   * the in-progress turn. Use `send()` or consume the `chat()` generator
-   * for real-time access to turn messages.
-   */
   getMessages() {
     return this.sessions.getMessages();
   }
-  /** Delete a session */
   async deleteSession(sessionId) {
     return this.sessions.deleteSession(sessionId);
   }
-  /** List all sessions */
   async listSessions() {
     return this.sessions.listSessions();
   }
-  /** Branch from current point */
   async branch(summary) {
     const leafId = this.sessions.getLeafId();
     if (!leafId) {
@@ -2614,226 +3479,83 @@ var Agent = class _Agent {
   // ============================================================================
   // Context Management
   // ============================================================================
-  /**
-   * Get context window statistics.
-   *
-   * Useful for UI to display context utilization like:
-   * - Progress bar showing how full the context is
-   * - Warning when approaching limit
-   * - Info about when compaction will trigger
-   *
-   * @example
-   * ```typescript
-   * const stats = agent.getContextStats();
-   * console.log(`Context: ${stats.utilizationPercent}% used`);
-   * if (stats.shouldPrune) {
-   *   console.log('Context will be compacted soon');
-   * }
-   * ```
-   */
   getContextStats() {
-    return this.contextManager.getStats(this.sessions.getMessages());
+    return getAgentContextStats({
+      contextManager: this.contextManager,
+      sessions: this.sessions
+    });
   }
-  /**
-   * Manually trigger context compaction.
-   *
-   * Usually auto-compaction handles this, but you can trigger it manually
-   * if needed (e.g., before a long operation).
-   *
-   * @returns Pruning result with details about what was removed/summarized
-   */
   async compactContext() {
-    return await compactAgentContext({
+    return await compactLoadedAgentContext({
       contextManager: this.contextManager,
       sessions: this.sessions,
-      logger: this._logger
+      logger: this._logger,
+      memoryProvider: this.memoryProvider,
+      sessionId: this.sessions.getSessionId() ?? void 0,
+      cwd: this.config.cwd
+    });
+  }
+  async compactMessages(messages, options = {}) {
+    return await compactAgentMessageList({
+      contextManager: this.contextManager,
+      messages,
+      logger: this._logger,
+      force: options.force,
+      memoryProvider: this.memoryProvider,
+      sessionId: this.sessions.getSessionId() ?? void 0,
+      cwd: this.config.cwd
     });
   }
-  /**
-   * Clear remembered doom loop tools.
-   *
-   * When a user says "remember" for a doom loop, that tool is added
-   * to a set that skips future doom loop checks. Call this to reset.
-   */
   clearRememberedDoomLoopTools() {
     this.rememberedDoomLoopTools.clear();
   }
   // ============================================================================
   // Intervention (Mid-Turn Message Injection)
   // ============================================================================
-  /**
-   * Inject a message at the next step boundary of a running turn.
-   *
-   * This is the primary redirection mechanism. When the agent is
-   * streaming a multi-step response (calling tools, reasoning, etc.),
-   * this injects a user message before the next LLM call. The LLM
-   * sees the intervention and can adjust its behavior.
-   *
-   * Uses Vercel AI SDK v6's `prepareStep` hook — no polling, no
-   * custom loop code. The SDK handles the injection naturally.
-   *
-   * Safe to call from any async context (UI event handlers, WebSocket
-   * callbacks, timers, etc.) 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.
-   * 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
-   *
-   * @example
-   * ```typescript
-   * // Start a streaming turn
-   * const stream = agent.chat("session-1", "refactor the auth module");
-   *
-   * // From a UI handler (another async context):
-   * agent.intervene("stop, focus only on JWT validation in auth.ts");
-   *
-   * // The stream will yield an intervention-applied event
-   * for await (const event of stream) {
-   *   if (event.type === "intervention-applied") {
-   *     console.log(`Redirected: ${event.message}`);
-   *   }
-   * }
-   * ```
-   */
   intervene(message) {
     return this.getInterventionControllerForTurn().intervene(message);
   }
-  /**
-   * Queue a message for after the current turn completes.
-   *
-   * Unlike `intervene()`, this does **not** interrupt the current turn.
-   * The message is held and available via `drainQueuedNext()` after
-   * `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
-   *
-   * @example
-   * ```typescript
-   * agent.queueNext("now run the test suite");
-   *
-   * for await (const event of agent.chat("s1", "fix the bug")) {
-   *   // ... handle events
-   * }
-   *
-   * // After turn completes, check for queued messages
-   * if (agent.hasQueuedNext()) {
-   *   const next = agent.drainQueuedNext();
-   *   for (const item of next) {
-   *     // Send as a new turn
-   *     for await (const ev of agent.chat("s1", item.message)) { ... }
-   *   }
-   * }
-   * ```
-   */
   queueNext(message) {
     return this.getInterventionControllerForTurn().queueNext(message);
   }
-  /** Whether there are deferred messages queued for after the turn */
   hasQueuedNext() {
     return this.getInterventionControllerForTurn().hasDeferred;
   }
-  /** Drain and return all deferred messages (clears the queue) */
   drainQueuedNext() {
     return this.getInterventionControllerForTurn().drainDeferred();
   }
-  /**
-   * Get the raw intervention controller for advanced use cases.
-   *
-   * Use this when you need fine-grained control over the intervention
-   * lifecycle (e.g., checking pending count, clearing queues, setting
-   * custom `onApplied` callbacks).
-   *
-   * @internal
-   */
   getInterventionController() {
     return this.getInterventionControllerForTurn();
   }
   // ============================================================================
   // Turn Tracking
   // ============================================================================
-  /**
-   * Get the unified diff for all file changes in the current/last turn.
-   *
-   * @example
-   * ```typescript
-   * const diff = await agent.getTurnDiff();
-   * if (diff) {
-   *   console.log('Changes this turn:\n', diff);
-   * }
-   * ```
-   */
   async getTurnDiff() {
     return this.turnTracker.getDiff();
   }
-  /**
-   * Get list of files being tracked in the current turn.
-   */
   getTrackedFiles() {
     return this.turnTracker.getTrackedFiles();
   }
-  /**
-   * Undo all file changes from the current turn.
-   * Restores files to their state before the turn started.
-   *
-   * @example
-   * ```typescript
-   * const result = await agent.undoTurn();
-   * console.log(`Restored ${result.restored.length} files`);
-   * if (result.failed.length > 0) {
-   *   console.log('Failed to restore:', result.failed);
-   * }
-   * ```
-   */
   async undoTurn() {
     return this.turnTracker.undoTurn();
   }
-  /**
-   * Undo changes to specific files only.
-   *
-   * @param files - Array of file paths to restore (relative to cwd)
-   */
   async undoFiles(files) {
     return this.turnTracker.undoFiles(files);
   }
-  /**
-   * Check if currently tracking a turn.
-   */
   isTrackingTurn() {
     return this.turnTracker.isInTurn();
   }
-  /**
-   * Get access to the raw turn tracker for advanced use cases.
-   *
-   * @internal
-   */
   getTurnTracker() {
     return this.turnTracker;
   }
   // ============================================================================
   // Configuration
   // ============================================================================
-  /**
-   * Update system prompt.
-   *
-   * If the agent is using the prompt pipeline, calling this switches
-   * to flat string mode (disabling the pipeline). To modify the pipeline
-   * instead, use `getPromptBuilder()`.
-   */
   setSystemPrompt(prompt) {
     this.config.systemPrompt = prompt;
     this.promptBuilder = void 0;
     this.resetPromptScopedTools();
   }
-  /** Update working directory */
   setCwd(cwd) {
     this.config.cwd = cwd;
     this.turnTracker = createTurnTracker({ cwd });
@@ -2843,13 +3565,10 @@ var Agent = class _Agent {
     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);
-    }
+    this.contextManager.setModel(model);
     if (this.config.contextWindow === void 0) {
       const modelId = extractModelId(model);
       const inferred = inferContextWindow(modelId);
@@ -2861,41 +3580,12 @@ var Agent = class _Agent {
       }
     }
   }
-  /**
-   * Get the prompt builder (when using pipeline mode).
-   * Returns undefined if using flat string mode.
-   *
-   * Use this to add/remove sections, clear caches, or inspect
-   * the prompt composition without switching to flat mode.
-   *
-   * @example
-   * ```typescript
-   * const builder = agent.getPromptBuilder();
-   * if (builder) {
-   *   builder.addSection({
-   *     id: "task-context",
-   *     label: "Task Context",
-   *     content: "Focus on fixing authentication bugs.",
-   *     priority: 60,
-   *   });
-   * }
-   * ```
-   */
   getPromptBuilder() {
     return this.promptBuilder;
   }
-  /**
-   * Check if the agent is using the prompt pipeline.
-   */
   isUsingPromptPipeline() {
     return this.promptBuilder !== void 0;
   }
-  /**
-   * Build the effective system prompts for a turn.
-   *
-   * This mirrors the prompt resolution path used by `chat()` so external host
-   * runtimes can start durable turns without duplicating prompt assembly.
-   */
   async buildSystemPrompts(sessionId, override) {
     await this.ensureSkillTools();
     return await buildAgentSystemPrompts({
@@ -2907,10 +3597,6 @@ var Agent = class _Agent {
       middlewareRunner: this.middlewareRunner
     });
   }
-  /**
-   * Return the runtime configuration required by the extracted turn-step
-   * helpers.
-   */
   getTurnRuntimeConfig() {
     return createAgentTurnRuntimeConfig({
       config: this.config,
@@ -2918,90 +3604,37 @@ var Agent = class _Agent {
       reserveTokens: this.contextManager.getLimits().reserveTokens
     });
   }
-  /**
-   * Get the configured tool host.
-   */
   getHost() {
     return this.host;
   }
-  /**
-   * Get the configured sandbox session, if one was provided.
-   */
   getSandbox() {
     return this.sandbox;
   }
-  /**
-   * Get the configured human-input controller, if one was provided.
-   */
   getHumanInputController() {
     return this.humanInputController;
   }
-  /**
-   * Whether any registered tool advertises human-input semantics.
-   */
+  getMemoryProvider() {
+    return this.memoryProvider;
+  }
   hasHumanInputTools() {
-    return [...this.tools.values()].some(
-      (tool) => tool.capabilitiesHint?.humanInput === true
-    );
+    return hasAgentHumanInputTools(this.tools);
   }
-  /**
-   * Get the configured middleware runner.
-   *
-   * The runner is immutable after construction, so it is safe to reuse in
-   * durable activity helpers that need the same middleware stack.
-   */
   getMiddlewareRunner() {
     return this.middlewareRunner;
   }
-  /**
-   * Get the configured middleware stack.
-   */
   getMiddleware() {
     return this.middlewareRunner.getMiddleware();
   }
-  /**
-   * Ensure MCP is connected and return the current MCP tool set.
-   */
   async getMcpTools() {
     return await this.ensureMCPConnected();
   }
   // ============================================================================
   // Sub-Agents (Forking)
   // ============================================================================
-  /**
-   * Fork this agent to create a sub-agent with modified configuration.
-   *
-   * Sub-agents share the same session manager but can have different:
-   * - System prompts (specialized for tasks)
-   * - Tools (restricted subset)
-   * - Models (cheaper/faster for simple tasks)
-   * - Reasoning levels
-   *
-   * @example
-   * ```typescript
-   * // Create an exploration sub-agent with read-only tools
-   * const explorer = agent.fork({
-   *   name: "explore",
-   *   systemPrompt: "You explore codebases. Only use read and search tools.",
-   *   tools: [readTool, grepTool, globTool],
-   * });
-   *
-   * // Run the sub-agent
-   * const result = await explorer.run({
-   *   parentSessionId: "main-session",
-   *   message: "Find all API endpoints",
-   * });
-   * ```
-   */
   fork(options = {}) {
-    const effectiveOptions = resolveForkOptions(
-      options,
-      Array.from(this.tools.values()),
-      this.config.systemPrompt
-    );
     return new _Agent(
-      createForkedAgentConfig({
-        forkOptions: effectiveOptions,
+      createSubAgentConfig({
+        forkOptions: options,
         parentConfig: this.config,
         parentTools: Array.from(this.tools.values()),
         reasoningLevel: this.state.reasoningLevel,
@@ -3016,49 +3649,9 @@ var Agent = class _Agent {
       })
     );
   }
-  /**
-   * Create a sub-agent with a profile.
-   *
-   * Convenience method that applies a profile and returns a forked agent.
-   *
-   * @example
-   * ```typescript
-   * import { Profiles } from "@cuylabs/agent-core";
-   *
-   * // Create an exploration sub-agent
-   * const explorer = agent.withProfile(Profiles.explore);
-   * const result = await explorer.run({
-   *   message: "Find all API routes in this project",
-   * });
-   *
-   * // Create a careful review sub-agent
-   * const reviewer = agent.withProfile(Profiles.review);
-   * const review = await reviewer.run({
-   *   message: "Review src/auth.ts for security issues",
-   * });
-   * ```
-   */
   withProfile(profile) {
     return this.fork({ profile });
   }
-  /**
-   * Run a task in an isolated sub-agent session.
-   *
-   * Creates a new session linked to the parent, runs the task to completion,
-   * and returns the result. The sub-agent session is preserved for inspection.
-   *
-   * @example
-   * ```typescript
-   * const result = await agent.run({
-   *   parentSessionId: "main-session",
-   *   message: "Review this code for security issues",
-   *   title: "Security Review",
-   * });
-   *
-   * console.log(result.response);
-   * console.log(`Sub-agent session: ${result.sessionId}`);
-   * ```
-   */
   async run(options) {
     const sessions = this.createSessionManager();
     const sessionId = await createSubAgentRunSession({
@@ -3078,54 +3671,50 @@ var Agent = class _Agent {
   // =========================================================================
   // MCP Methods
   // =========================================================================
-  /**
-   * Get the MCP manager (if configured)
-   */
   getMCP() {
     return this.mcpManager;
   }
-  /**
-   * Check if MCP is configured
-   */
   hasMCP() {
     return this.mcpManager !== void 0;
   }
-  /**
-   * Reconnect to MCP servers
-   *
-   * Use this after network issues or when server availability changes.
-   * Clears tool cache and reconnects all servers.
-   */
   async reconnectMCP() {
-    if (!this.mcpManager) return;
-    const nextState = await closeMcpManager(this.mcpManager);
+    const nextState = await reconnectAgentMcp(
+      {
+        manager: this.mcpManager,
+        connected: this.mcpConnected,
+        cachedTools: this.mcpToolsCache
+      },
+      this._logger
+    );
     this.mcpConnected = nextState.connected;
     this.mcpToolsCache = nextState.cachedTools;
-    await this.ensureMCPConnected();
   }
   // =========================================================================
   // Cleanup
   // =========================================================================
-  /**
-   * Close the agent and clean up resources
-   *
-   * Flushes and shuts down the tracing provider (when `tracing` was configured),
-   * closes MCP connections if configured.
-   * After calling close(), the agent should not be used.
-   */
   async close() {
     this._signal.clear();
     this.humanInputController?.cancelAll("Agent closed");
+    await this.memoryProvider?.shutdown?.();
     if (this.tracingShutdown) {
       await this.tracingShutdown();
     }
-    const nextState = await closeMcpManager(this.mcpManager);
+    const nextState = await closeAgentMcp(this.mcpManager);
     this.mcpConnected = nextState.connected;
     this.mcpToolsCache = nextState.cachedTools;
   }
 };
 
 // src/agent/event-printer.ts
+function formatContextCompactionEvent(event) {
+  if (event.removedCount === 0 && event.tokensRemoved > 0 && !event.cutReason) {
+    return `\u{1F4E6} Context compaction (${event.phase}): compacted tool context, ${event.tokensRemoved} tokens
+`;
+  }
+  const cutReason = event.cutReason ? `, reason=${event.cutReason}` : "";
+  return `\u{1F4E6} Context compaction (${event.phase}): removed ${event.removedCount} message(s), ${event.tokensRemoved} tokens${cutReason}
+`;
+}
 function createEventPrinter(options = {}) {
   const {
     tools = true,
@@ -3230,6 +3819,9 @@ function createEventPrinter(options = {}) {
 `
           );
         break;
+      case "context-compaction":
+        if (safety) stderr.write(formatContextCompactionEvent(event));
+        break;
       case "turn-summary":
         if (safety)
           stderr.write(
@@ -3348,16 +3940,22 @@ function canSeedQueuedFollowUp(record) {
   return record.status === "queued" && record.mode === "auto-run";
 }
 export {
+  AGENT_CONTEXT_FRAGMENT_CLOSE,
+  AGENT_CONTEXT_FRAGMENT_OPEN,
+  AGENT_CONTEXT_FRAGMENT_TAG,
   Agent,
   AgentTurnEngine,
+  AgentTurnStateConflictError,
   ApprovalDeniedError,
   ApprovalTimeoutError,
   CacheCapabilitySource,
   CapabilityCache,
   ClientCredentialsProvider,
-  ContextManager,
   ContextOverflowError,
+  ContextSummaryModelRequiredError,
+  ContextWindowManager,
   DEFAULT_AGENT_NAME,
+  DEFAULT_COMPACTION_EFFECTIVE_MIN_SAVINGS_RATIO,
   DEFAULT_CONTEXT_LIMITS,
   DEFAULT_DISPATCH_TOOL_IDS,
   DEFAULT_EXTERNAL_DIRS,
@@ -3367,7 +3965,7 @@ export {
   DEFAULT_LOCAL_DISPATCH_TITLE_PREFIX,
   DEFAULT_MAX_DEPTH,
   DEFAULT_MAX_FILE_SIZE,
-  DEFAULT_MAX_TOKENS as DEFAULT_MAX_OUTPUT_TOKENS,
+  DEFAULT_MAX_OUTPUT_TOKENS,
   DEFAULT_MAX_SCAN_DEPTH,
   DEFAULT_MAX_STEPS,
   DEFAULT_MAX_TOKENS,
@@ -3377,6 +3975,8 @@ export {
   DEFAULT_SUBAGENT_CONCURRENCY,
   DEFAULT_SUBAGENT_DEPTH,
   DEFAULT_SUBAGENT_SESSION_PREFIX,
+  DEFAULT_SUMMARY_MAX_INPUT_TOKENS,
+  DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS,
   DEFAULT_SYSTEM_PROMPT,
   DISPATCH_STATES,
   DoomLoopError,
@@ -3437,7 +4037,10 @@ export {
   advanceAgentTurnState,
   allApprovalConditions,
   anyApprovalConditions,
+  applyAgentContextFragments,
+  applyAgentContextFragmentsWithReport,
   applyAgentWorkflowCommitResult,
+  applyAgentWorkflowContextCompactionResult,
   applyAgentWorkflowModelStepResult,
   applyAgentWorkflowToolBatchResult,
   applyAgentWorkflowToolCallResult,
@@ -3446,6 +4049,7 @@ export {
   applyWorkflowInterventions,
   approvalMiddleware,
   approvalRequestsOverlap,
+  assembleModelContext,
   autoDetectStreamProvider,
   buildAnthropicOptions,
   buildApprovalRuleContext,
@@ -3466,6 +4070,7 @@ export {
   buildToolSet,
   buildXAIOptions,
   calculateDelay,
+  canGenerateCompactionSummary,
   canSeedQueuedFollowUp,
   careful,
   clearInstalledSubAgents,
@@ -3473,12 +4078,14 @@ export {
   code,
   commitOutput,
   commitStep,
+  compactAgentMessages,
   configureDefaultSessionManager,
   configureResolver,
   configureSubAgents,
   convertAgentMessagesToModelMessages,
   coordinatorToolDescriptions,
   createAgent,
+  createAgentContextFragmentMessage,
   createAgentTaskRunner,
   createAgentTurnEngine,
   createAgentTurnState,
@@ -3488,6 +4095,8 @@ export {
   createApprovalHandler,
   createApprovalPolicyPreset,
   createCloseAgentTool,
+  createCompactionEffectiveness,
+  createCompactionSummaryContent,
   createCompositeDispatchTaskExecutor,
   createConditionalApprovalRule,
   createConsoleLogger,
@@ -3509,6 +4118,7 @@ export {
   createInvokeAgentTool,
   createLocalDispatchRuntime,
   createMCPManager,
+  createMemoryMiddleware,
   createMessageEntry,
   createMetadataEntry,
   createProfile,
@@ -3534,6 +4144,7 @@ export {
   createTurnTracker,
   createWaitAgentTool,
   currentScope,
+  decideContextCompaction,
   defaultAgentTaskCheckpointStrategy,
   defaultRegistry,
   defaultToolHostRegistry,
@@ -3556,6 +4167,7 @@ export {
   executeAgentToolCall,
   explore,
   extractApprovalPatterns,
+  extractCompactionSummaryText,
   extractFilePathsFromArgs,
   extractModelId,
   extractProvider,
@@ -3564,7 +4176,6 @@ export {
   failAgentWorkflowTurnState,
   filterTools,
   findCapabilityOverride,
-  findCutPoint,
   formatApprovalDeniedReason,
   formatAsyncSpawnedResult,
   formatCancelledAgentResult,
@@ -3576,6 +4187,7 @@ export {
   formatEnvironment,
   formatInstructions,
   formatInvalidAgentTypeResult,
+  formatMemoryContextFragment,
   formatMissingAgentsResult,
   formatSpawnBlockedResult,
   formatSyncSubAgentErrorResult,
@@ -3585,8 +4197,12 @@ export {
   formatWaitTimeoutResult,
   gatherEnvironment,
   generateEntryId,
+  generateSplitTurnSummary,
+  generateSummary,
+  getAgentContextFragmentMetadata,
   getAvailableFamilies,
   getConfiguredSubAgents,
+  getCurrentAgentTurnStepRecord,
   getDataDir,
   getDefaultResolver,
   getDefaultSessionManager,
@@ -3618,11 +4234,14 @@ export {
   inferResourceType,
   installLocalSubAgents,
   installSubAgentTools,
+  isAgentContextFragmentMessage,
   isApprovalMiddleware,
   isBlockedModelCall,
+  isContextOverflowing,
   isDefinedPlugin,
   isHumanInputController,
   isMarkdownSubAgentRole,
+  isRenderedAgentContextFragment,
   isRetryable,
   isRetryableCategory,
   likelySupportsReasoning,
@@ -3639,34 +4258,48 @@ export {
   matchApprovalRisks,
   matchApprovalSessions,
   matchApprovalStringPrefixes,
+  mergeAgentTurnStateProgress,
   mergeInspection,
   mergeProfiles,
+  normalizeAgentContextFragment,
   normalizeApprovalCascadePolicy,
   normalizeFollowUpMode,
+  normalizeMemoryRecords,
   normalizeRememberScopes,
   normalizeToolReplayPolicy,
   otelMiddleware,
   parseFrontmatter,
   parseJSONL,
   parseMarkdownSubAgentRole,
+  parseRenderedAgentContextFragment,
   parseRetryDelay,
   parseSubAgentRoleFrontmatter,
   parseSubAgentToolSpec,
   plan,
+  planCompactionCut,
   planNextAgentWorkflowOperation,
   prepareModelStep,
   processStepStream,
   promptCacheMiddleware,
+  pruneContext,
+  pruneToolContext,
+  pruneToolContextWithReport,
   queueWorkflowFollowUps,
   quick,
   recordAgentWorkflowReplayDecision,
+  redactSummaryText,
+  renderAgentContextFragment,
   requiresToolHost,
   resetFrameworkAliases,
   resetPluginLoader,
   resolveAgentDefaults,
+  resolveAgentMemoryConfig,
+  resolveAgentMemoryTurnConfig,
   resolveCapability,
+  resolveContextSummaryPolicy,
   resolveFrameworkAliases,
   resolveQueuedFollowUp,
+  resolveSummaryOutputTokens,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,
   restoreScope,
@@ -3677,10 +4310,13 @@ export {
   sandboxDefaultsProvider,
   selectRememberScope,
   serializeMessage,
+  serializeMessagesForSummary,
   serviceAccountServer,
   shouldCaptureBaseline,
   shouldCascadeApprovalDecision,
+  shouldFallbackOnSummaryFailure,
   shouldIncludeReasoningSummary,
+  shouldPruneContext,
   shouldRetry,
   silentLogger,
   sleep,