@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/index.js

@@ -1,59 +1,101 @@
 import {
-  FileStorage,
-  MemoryStorage,
-  STORAGE_VERSION,
-  SessionManager,
-  buildEntryPath,
-  buildMessagesFromEntries,
-  configureDefaultSessionManager,
-  createMessageEntry,
-  createMetadataEntry,
-  deserializeMessage,
-  extractSessionInfo,
-  generateEntryId,
-  getDataDir,
-  getDefaultSessionManager,
-  getGitRootHash,
-  getLeafId,
-  getProjectId,
-  getProjectSessionsDir,
-  getSessionsDir,
-  parseJSONL,
-  serializeMessage,
-  toJSONL,
-  toJSONLBatch
-} from "./chunk-BDBZ3SLK.js";
+  DEFAULT_SUBAGENT_CONCURRENCY,
+  DEFAULT_SUBAGENT_DEPTH,
+  DEFAULT_SUBAGENT_SESSION_PREFIX,
+  LOCAL_SUBAGENT_BACKEND,
+  SUBAGENT_TOOL_IDS,
+  clearInstalledSubAgents,
+  configureSubAgents,
+  createCloseAgentTool,
+  createInvokeAgentTool,
+  createSubAgentTools,
+  createWaitAgentTool,
+  discoverSubAgentRoles,
+  formatAsyncSpawnedResult,
+  formatCancelledAgentResult,
+  formatCloseAlreadyResolvedResult,
+  formatCloseMissingAgentResult,
+  formatInvalidAgentTypeResult,
+  formatMissingAgentsResult,
+  formatSpawnBlockedResult,
+  formatSyncSubAgentErrorResult,
+  formatSyncSubAgentResult,
+  formatWaitErrorResult,
+  formatWaitResult,
+  formatWaitTimeoutResult,
+  getConfiguredSubAgents,
+  getInstalledSubAgentBackend,
+  getProjectSubAgentRolesDir,
+  getUserSubAgentRolesDir,
+  installLocalSubAgents,
+  installSubAgentTools,
+  isMarkdownSubAgentRole,
+  parseMarkdownSubAgentRole,
+  parseSubAgentRoleFrontmatter,
+  parseSubAgentToolSpec,
+  toSubAgentRole
+} from "./chunk-2O4MCSQS.js";
 import {
-  DEFAULT_MAX_CONCURRENT,
-  DEFAULT_MAX_SPAWN_DEPTH,
-  DEFAULT_SESSION_TITLE_PREFIX,
-  SubAgentTracker,
-  createSubAgentTools
-} from "./chunk-7MUFEN4K.js";
+  InMemoryMailboxStore,
+  InMemoryTaskBoardStore,
+  Mailbox,
+  TERMINAL_STATUSES,
+  TaskBoard,
+  TaskConflictError,
+  TeamCoordinator,
+  addTokenUsage,
+  buildCoordinatorNotificationEvent,
+  buildCoordinatorSystemPrompt,
+  coordinatorToolDescriptions,
+  createTeamCoordinator,
+  evaluateCoordinatorRoundTransition,
+  formatCoordinatorRoundMessage,
+  formatCoordinatorTaskNotifications,
+  formatCoordinatorWorkerReports,
+  teamPermissionPolicy
+} from "./chunk-MXAP4UG6.js";
 import {
   ToolRegistry,
+  createToolSearchTool,
   defaultRegistry
-} from "./chunk-SDSBEQXG.js";
+} from "./chunk-KYLPMBHD.js";
 import {
-  TurnChangeTracker,
-  clearCheckpoints,
-  createCheckpointManager,
-  createTurnTracker
-} from "./chunk-VBWWUHWI.js";
+  ToolHostRegistry,
+  defaultToolHostRegistry,
+  localHost
+} from "./chunk-X4VN4GIJ.js";
+import {
+  LayeredSettings,
+  NullSettings,
+  PluginEventBus,
+  PluginRegistry,
+  StaticSettings,
+  ValidatedSettings,
+  definePlugin,
+  discoverPlugins,
+  getPluginLoader,
+  isDefinedPlugin,
+  loadPluginModule,
+  resetFrameworkAliases,
+  resetPluginLoader,
+  resolveFrameworkAliases
+} from "./chunk-QAL3OMI3.js";
+import {
+  applyProfile,
+  createProfile,
+  filterTools,
+  mergeProfiles
+} from "./chunk-TIHPYVAJ.js";
 import {
-  Presets,
-  applyPreset,
+  Profiles,
   careful,
   code,
-  createPreset,
   explore,
-  filterTools,
-  mergePresets,
   plan,
   quick,
   review,
   watch
-} from "./chunk-CAA7FHIH.js";
+} from "./chunk-6HZBHFOL.js";
 import {
   DEFAULT_INSTRUCTION_PATTERNS,
   DEFAULT_MAX_DEPTH,
@@ -75,32 +117,121 @@ import {
   getTemplate,
   loadGlobalInstructions,
   summarizeEnvironment
-} from "./chunk-IVUJDISU.js";
+} from "./chunk-GFTW23FV.js";
+import "./chunk-VOUEJSW6.js";
+import {
+  createSkillResourceTool,
+  createSkillTool,
+  createSkillTools
+} from "./chunk-TOTDGK3P.js";
+import {
+  DEFAULT_EXTERNAL_DIRS,
+  DEFAULT_MAX_SCAN_DEPTH,
+  DEFAULT_SKILL_MAX_SIZE,
+  SKILL_FILENAME,
+  SkillRegistry,
+  createSkillRegistry,
+  discoverSkills,
+  emptySkillRegistry,
+  inferResourceType,
+  loadResourceContent,
+  loadSkillContent,
+  loadSkillMetadata,
+  parseFrontmatter
+} from "./chunk-SPILYYDF.js";
+import {
+  createCompositeDispatchTaskExecutor,
+  createDispatchExternalTaskControl,
+  createDispatchTaskExecutor,
+  createRuntimeDispatchExecutor,
+  createRuntimeDispatchTargets,
+  ensureNonEmpty,
+  mergeInspection
+} from "./chunk-5FMSGQVX.js";
+import {
+  DEFAULT_DISPATCH_TOOL_IDS,
+  DEFAULT_LOCAL_DISPATCH_CONCURRENCY,
+  DEFAULT_LOCAL_DISPATCH_DEPTH,
+  DEFAULT_LOCAL_DISPATCH_TITLE_PREFIX,
+  DISPATCH_STATES,
+  createDispatchTools,
+  createLocalDispatchRuntime,
+  createSubAgentRunSession,
+  ensureSessionLoaded,
+  getVisibleSessionMessages,
+  repairOrphanedToolCalls
+} from "./chunk-SSFBF3US.js";
+import {
+  sleep
+} from "./chunk-SZ2XBPTW.js";
+import {
+  MAX_BYTES,
+  MAX_LINES,
+  Tool,
+  normalizeToolReplayPolicy,
+  truncateOutput
+} from "./chunk-Q742PSH3.js";
+import {
+  FileStorage,
+  MemoryStorage,
+  STORAGE_VERSION,
+  SessionManager,
+  buildEntryPath,
+  buildMessagesFromEntries,
+  configureDefaultSessionManager,
+  createMessageEntry,
+  createMetadataEntry,
+  deserializeMessage,
+  extractSessionInfo,
+  generateEntryId,
+  getDataDir,
+  getDefaultSessionManager,
+  getGitRootHash,
+  getLeafId,
+  getProjectId,
+  getProjectSessionsDir,
+  getSessionsDir,
+  parseJSONL,
+  serializeMessage,
+  toJSONL,
+  toJSONLBatch
+} from "./chunk-ICZ66572.js";
+import {
+  createEventBus
+} from "./chunk-2TTOLHBT.js";
 import {
   AgentTurnEngine,
+  ContextManager,
   ContextOverflowError,
+  DEFAULT_CONTEXT_LIMITS,
   DoomLoopError,
   advanceAgentTurnState,
   applyAgentWorkflowCommitResult,
   applyAgentWorkflowModelStepResult,
   applyAgentWorkflowToolBatchResult,
   applyAgentWorkflowToolCallResult,
+  applyWorkflowInterventions,
   cloneAgentWorkflowTurnState,
   commitOutput,
   commitStep,
-  convertAgentMessagesToModelMessages,
   createAgentTaskRunner,
   createAgentTurnEngine,
   createAgentTurnState,
   createAgentTurnStepCommitBatch,
   createAgentWorkflowTurnState,
   defaultAgentTaskCheckpointStrategy,
+  drainWorkflowInterventions,
+  estimateConversationTokens,
+  estimateMessageTokens,
+  estimateTokens,
   failAgentTurnState,
   failAgentWorkflowTurnState,
+  findCutPoint,
+  getUsableTokenLimit,
   planNextAgentWorkflowOperation,
   prepareModelStep,
   processStepStream,
-  processStream,
+  queueWorkflowFollowUps,
   recordAgentWorkflowReplayDecision,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,
@@ -108,88 +239,52 @@ import {
   runToolBatch,
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages
-} from "./chunk-4BDA7DQY.js";
-import {
-  LocalSignal
-} from "./chunk-KUVSERLJ.js";
-import {
-  createSkillResourceTool,
-  createSkillTool,
-  createSkillTools
-} from "./chunk-YUUJK53A.js";
+} from "./chunk-WBPOZ7CL.js";
 import {
-  MAX_BYTES,
-  MAX_LINES,
-  TRUNCATE_DIR,
-  TRUNCATE_GLOB,
-  Tool,
-  defineTool,
-  formatSize,
-  normalizeToolReplayPolicy,
-  truncateOutput
-} from "./chunk-P6YF7USR.js";
-import {
-  DEFAULT_EXTERNAL_DIRS,
-  DEFAULT_MAX_SCAN_DEPTH,
-  DEFAULT_SKILL_MAX_SIZE,
-  SKILL_FILENAME,
-  SkillRegistry,
-  createSkillRegistry,
-  discoverSkills,
-  emptySkillRegistry,
-  inferResourceType,
-  loadResourceContent,
-  loadSkillContent,
-  loadSkillMetadata,
-  parseFrontmatter
-} from "./chunk-LRHOS4ZN.js";
-import {
-  ContextManager,
-  DEFAULT_CONTEXT_LIMITS,
-  PRUNE_PROTECTED_TOOLS,
-  estimateConversationTokens,
-  estimateMessageTokens,
-  estimateTokens,
-  findCutPoint,
-  generateSummary,
-  isContextOverflowing,
-  pruneContext,
-  pruneToolResults,
-  shouldPruneContext
-} from "./chunk-WWYYNWEW.js";
-import {
-  dockerHost,
-  localHost
-} from "./chunk-VNQBHPCT.js";
-import {
-  DEFAULT_MAX_OUTPUT_TOKENS,
   DEFAULT_RETRY_CONFIG,
   Inference,
-  LLM,
-  OUTPUT_TOKEN_MAX,
+  buildModelCallContext,
   buildToolSet,
   calculateDelay,
+  convertAgentMessagesToModelMessages,
   createRetryHandler,
   createRetryState,
   shouldRetry,
-  sleep,
   stream,
   streamOnce,
   streamStep,
   withRetry
-} from "./chunk-N6HWIEEA.js";
-import {
-  executeAgentToolCall
-} from "./chunk-7VKQ4WPB.js";
+} from "./chunk-CMYN2RCB.js";
 import {
+  PRUNE_PROTECTED_TOOLS,
+  accumulateUsage,
+  currentScope,
+  executeAgentToolCall,
   extractFilePathsFromArgs,
+  restoreScope,
   shouldCaptureBaseline,
-  withFileTracking
-} from "./chunk-VEKUXUVF.js";
+  snapshotScope,
+  streamWithinScope,
+  withinScope
+} from "./chunk-5NVVNXPQ.js";
+import {
+  LLMError,
+  getErrorCategory,
+  getRetryDelay,
+  isRetryable,
+  isRetryableCategory,
+  parseRetryDelay
+} from "./chunk-N3VX7FEE.js";
 import {
+  CacheCapabilitySource,
+  CapabilityCache,
   EXTENDED_LEVELS,
   FIXED_LEVELS,
+  ModelCapabilityResolver,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
   STANDARD_LEVELS,
+  applyCapabilityOverride,
   buildAnthropicOptions,
   buildBedrockOptions,
   buildGoogleOptions,
@@ -199,75 +294,717 @@ import {
   buildReasoningOptions,
   buildReasoningOptionsSync,
   buildXAIOptions,
+  configureResolver,
+  createResolver,
+  findCapabilityOverride,
+  getDefaultResolver,
+  getNetworkStatus,
   getProviderOptionsKey,
   getReasoningConfig,
   getReasoningConfigSync,
   shouldIncludeReasoningSummary,
   supportsReasoning,
   supportsReasoningSync
-} from "./chunk-SQU2AJHO.js";
-import {
-  createScope,
-  currentScope,
-  restoreScope,
-  snapshotScope,
-  streamWithinScope,
-  withinScope
-} from "./chunk-N7P4PN3O.js";
-import {
-  LLMError,
-  getErrorCategory,
-  getRetryDelay,
-  isRetryable,
-  isRetryableCategory,
-  parseRetryDelay
-} from "./chunk-RZITT45F.js";
+} from "./chunk-RN6WZEUF.js";
+import "./chunk-SPBFQXOT.js";
 import {
   createMCPManager,
-  defineServer,
   httpServer,
   sseServer,
   stdioServer
-} from "./chunk-ZXAKHMWH.js";
+} from "./chunk-ROTGCYDW.js";
 import {
   MiddlewareRunner,
   approvalMiddleware,
   createTelemetryConfig,
+  isApprovalMiddleware,
   otelMiddleware,
   promptCacheMiddleware
-} from "./chunk-YSLSEQ6B.js";
+} from "./chunk-NDZWXCBZ.js";
 import {
-  ApprovalDeniedError,
-  ApprovalTimeoutError,
-  createApprovalHandler,
-  getToolRisk
-} from "./chunk-BFM2YHNM.js";
+  DEFAULT_AGENT_NAME,
+  DEFAULT_MAX_STEPS,
+  DEFAULT_MAX_TOKENS,
+  DEFAULT_SYSTEM_PROMPT,
+  isBlockedModelCall,
+  resolveAgentDefaults,
+  sandboxDefaultsProvider
+} from "./chunk-CJI7PVS2.js";
 import {
-  CacheCapabilitySource,
-  CapabilityCache,
   DEFAULT_RESOLVER_OPTIONS,
-  ModelCapabilityResolver,
   PatternCapabilitySource,
-  RemoteCapabilityFetcher,
-  RemoteCapabilitySource,
   SourcePriority,
-  applyCapabilityOverride,
-  configureResolver,
-  createResolver,
   extractModelId,
   extractProvider,
-  findCapabilityOverride,
-  getDefaultResolver,
-  getNetworkStatus,
+  getModelId,
   getProviderCompatibility,
+  getProviderId,
   inferContextWindow,
   inferProvider,
   likelySupportsReasoning
-} from "./chunk-RFEKJKTO.js";
+} from "./chunk-I6PKJ7XQ.js";
 import {
-  getModelId,
-  getProviderId
-} from "./chunk-DWYX7ASF.js";
+  ApprovalDeniedError,
+  ApprovalTimeoutError,
+  allApprovalConditions,
+  anyApprovalConditions,
+  approvalRequestsOverlap,
+  buildApprovalRuleContext,
+  createApprovalCorrection,
+  createApprovalHandler,
+  createApprovalPolicyPreset,
+  createConditionalApprovalRule,
+  createDangerouslyAllowAllApprovalPolicy,
+  createHeadlessDenyApprovalPolicy,
+  createInteractiveApprovalPolicy,
+  createRememberedApprovalRules,
+  createRiskTierApprovalPolicy,
+  createThresholdApprovalRule,
+  createTrustedSessionApprovalPolicy,
+  formatApprovalDeniedReason,
+  getToolRisk,
+  matchApprovalArgValue,
+  matchApprovalNumericArg,
+  matchApprovalRisks,
+  matchApprovalSessions,
+  matchApprovalStringPrefixes,
+  normalizeApprovalCascadePolicy,
+  normalizeRememberScopes,
+  selectRememberScope,
+  shouldCascadeApprovalDecision
+} from "./chunk-V4RFNEET.js";
+import {
+  describeApprovalOperation,
+  extractApprovalPatterns,
+  getRequiredToolHost,
+  matchApprovalPattern,
+  requiresToolHost,
+  resolveCapability
+} from "./chunk-FII65CN7.js";
+import {
+  createConsoleLogger,
+  createFileLogger,
+  silentLogger
+} from "./chunk-T4UIX5D7.js";
+
+// src/tracking/turn-tracker/tracker.ts
+import { spawn } from "child_process";
+import { normalize, relative as relative2, resolve } from "path";
+
+// src/tracking/turn-tracker/diff.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, stat, unlink, writeFile } from "fs/promises";
+import { dirname, relative } from "path";
+async function captureTurnFileBaseline(absPath) {
+  try {
+    const content = await readFile(absPath, "utf-8");
+    const stats = await stat(absPath);
+    return {
+      path: absPath,
+      content,
+      mode: stats.mode,
+      hash: hashTurnTrackerContent(content),
+      capturedAt: /* @__PURE__ */ new Date()
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {
+        path: absPath,
+        content: null,
+        mode: null,
+        hash: null,
+        capturedAt: /* @__PURE__ */ new Date()
+      };
+    }
+    throw error;
+  }
+}
+async function restoreTurnTrackedFile(absPath, baseline) {
+  if (baseline.content === null) {
+    try {
+      await unlink(absPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    return;
+  }
+  await mkdir(dirname(absPath), { recursive: true });
+  await writeFile(absPath, baseline.content, {
+    mode: baseline.mode ?? void 0
+  });
+}
+async function computeTurnTrackerFileChange(options) {
+  const { cwd, absPath, baseline, preferGitDiff, canUseGitDiff } = options;
+  const relPath = relative(cwd, absPath);
+  const currentContent = await readTrackedFileContent(absPath);
+  let type;
+  if (baseline.content === null && currentContent === null) {
+    type = "unchanged";
+  } else if (baseline.content === null && currentContent !== null) {
+    type = "created";
+  } else if (baseline.content !== null && currentContent === null) {
+    type = "deleted";
+  } else if (baseline.content === currentContent) {
+    type = "unchanged";
+  } else {
+    type = "modified";
+  }
+  if (type === "unchanged") {
+    return { path: relPath, type, additions: 0, deletions: 0 };
+  }
+  const diff = await generateTurnTrackerDiff({
+    relPath,
+    oldContent: baseline.content,
+    newContent: currentContent,
+    preferGitDiff,
+    canUseGitDiff
+  });
+  const { additions, deletions } = countUnifiedDiffStats(diff);
+  return {
+    path: relPath,
+    type,
+    additions,
+    deletions,
+    diff
+  };
+}
+async function readTrackedFileContent(absPath) {
+  try {
+    return await readFile(absPath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function generateTurnTrackerDiff(options) {
+  const { relPath, oldContent, newContent, preferGitDiff, canUseGitDiff } = options;
+  const oldLines = (oldContent ?? "").split("\n");
+  const newLines = (newContent ?? "").split("\n");
+  if (preferGitDiff && canUseGitDiff) {
+    const gitDiff = await createGitStyleDiffPlaceholder();
+    if (gitDiff) {
+      return gitDiff;
+    }
+  }
+  return buildSimpleUnifiedDiff({
+    path: relPath,
+    oldLines,
+    newLines,
+    wasCreated: oldContent === null,
+    wasDeleted: newContent === null
+  });
+}
+function buildSimpleUnifiedDiff(options) {
+  const { path, oldLines, newLines, wasCreated, wasDeleted } = options;
+  const header = [
+    `--- a/${path}${wasCreated ? " (new file)" : ""}`,
+    `+++ b/${path}${wasDeleted ? " (deleted)" : ""}`
+  ];
+  const hunks = [];
+  if (wasCreated) {
+    hunks.push(`@@ -0,0 +1,${newLines.length} @@`);
+    for (const line of newLines) {
+      hunks.push(`+${line}`);
+    }
+  } else if (wasDeleted) {
+    hunks.push(`@@ -1,${oldLines.length} +0,0 @@`);
+    for (const line of oldLines) {
+      hunks.push(`-${line}`);
+    }
+  } else {
+    hunks.push(`@@ -1,${oldLines.length} +1,${newLines.length} @@`);
+    for (const line of oldLines) {
+      hunks.push(`-${line}`);
+    }
+    for (const line of newLines) {
+      hunks.push(`+${line}`);
+    }
+  }
+  return [...header, ...hunks].join("\n");
+}
+function countUnifiedDiffStats(diff) {
+  let additions = 0;
+  let deletions = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      additions++;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      deletions++;
+    }
+  }
+  return { additions, deletions };
+}
+function hashTurnTrackerContent(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+async function createGitStyleDiffPlaceholder() {
+  return null;
+}
+
+// src/tracking/turn-tracker/tracker.ts
+var TurnChangeTracker = class {
+  config;
+  currentTurn = null;
+  gitDetected = null;
+  log;
+  constructor(config, logger) {
+    this.config = {
+      cwd: resolve(config.cwd),
+      useGit: config.useGit ?? true,
+      maxTrackedFiles: config.maxTrackedFiles ?? 100
+    };
+    this.log = logger?.child("turn-tracker") ?? silentLogger;
+  }
+  startTurn(turnId) {
+    if (this.currentTurn && !this.currentTurn.completed) {
+      this.currentTurn.completed = true;
+    }
+    this.currentTurn = {
+      id: turnId,
+      startedAt: /* @__PURE__ */ new Date(),
+      baselines: /* @__PURE__ */ new Map(),
+      completed: false
+    };
+  }
+  async endTurn() {
+    if (!this.currentTurn) {
+      return {
+        turnId: "",
+        files: [],
+        totalTracked: 0,
+        additions: 0,
+        deletions: 0,
+        diff: null,
+        duration: 0
+      };
+    }
+    const turn = this.currentTurn;
+    turn.completed = true;
+    const files = [];
+    let additions = 0;
+    let deletions = 0;
+    const diffs = [];
+    for (const [absPath, baseline] of turn.baselines) {
+      const change = await this.computeFileChange(absPath, baseline);
+      files.push(change);
+      additions += change.additions;
+      deletions += change.deletions;
+      if (change.diff) {
+        diffs.push(change.diff);
+      }
+    }
+    files.sort((left, right) => left.path.localeCompare(right.path));
+    return {
+      turnId: turn.id,
+      files,
+      totalTracked: turn.baselines.size,
+      additions,
+      deletions,
+      diff: diffs.length > 0 ? diffs.join("\n") : null,
+      duration: Date.now() - turn.startedAt.getTime()
+    };
+  }
+  isInTurn() {
+    return this.currentTurn !== null && !this.currentTurn.completed;
+  }
+  getCurrentTurnId() {
+    return this.currentTurn?.id ?? null;
+  }
+  async beforeWrite(filePath) {
+    if (!this.currentTurn || this.currentTurn.completed) {
+      return false;
+    }
+    const absPath = resolve(this.config.cwd, filePath);
+    const normalizedPath = normalize(absPath);
+    if (this.currentTurn.baselines.has(normalizedPath)) {
+      return false;
+    }
+    if (this.currentTurn.baselines.size >= this.config.maxTrackedFiles) {
+      this.log.warn(
+        `Max tracked files (${this.config.maxTrackedFiles}) reached, skipping: ${filePath}`
+      );
+      return false;
+    }
+    const baseline = await captureTurnFileBaseline(normalizedPath);
+    this.currentTurn.baselines.set(normalizedPath, baseline);
+    return true;
+  }
+  getTrackedFiles() {
+    if (!this.currentTurn) {
+      return [];
+    }
+    return Array.from(this.currentTurn.baselines.keys()).map(
+      (path) => relative2(this.config.cwd, path)
+    );
+  }
+  isTracking(filePath) {
+    if (!this.currentTurn) {
+      return false;
+    }
+    const absPath = resolve(this.config.cwd, filePath);
+    return this.currentTurn.baselines.has(normalize(absPath));
+  }
+  async getDiff() {
+    if (!this.currentTurn || this.currentTurn.baselines.size === 0) {
+      return null;
+    }
+    const diffs = [];
+    for (const [absPath, baseline] of this.currentTurn.baselines) {
+      const change = await this.computeFileChange(absPath, baseline);
+      if (change.diff) {
+        diffs.push(change.diff);
+      }
+    }
+    return diffs.length > 0 ? diffs.join("\n") : null;
+  }
+  async getFileDiff(filePath) {
+    if (!this.currentTurn) {
+      return null;
+    }
+    const absPath = resolve(this.config.cwd, filePath);
+    const baseline = this.currentTurn.baselines.get(normalize(absPath));
+    if (!baseline) {
+      return null;
+    }
+    const change = await this.computeFileChange(absPath, baseline);
+    return change.diff ?? null;
+  }
+  async undoTurn() {
+    if (!this.currentTurn) {
+      return { restored: [], failed: [] };
+    }
+    const result = { restored: [], failed: [] };
+    for (const [absPath, baseline] of this.currentTurn.baselines) {
+      const relPath = relative2(this.config.cwd, absPath);
+      try {
+        await restoreTurnTrackedFile(absPath, baseline);
+        result.restored.push(relPath);
+      } catch (error) {
+        result.failed.push({
+          path: relPath,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return result;
+  }
+  async undoFiles(filePaths) {
+    if (!this.currentTurn) {
+      return { restored: [], failed: [] };
+    }
+    const result = { restored: [], failed: [] };
+    for (const filePath of filePaths) {
+      const absPath = resolve(this.config.cwd, filePath);
+      const normalizedPath = normalize(absPath);
+      const baseline = this.currentTurn.baselines.get(normalizedPath);
+      if (!baseline) {
+        result.failed.push({
+          path: filePath,
+          reason: "File not tracked in current turn"
+        });
+        continue;
+      }
+      try {
+        await restoreTurnTrackedFile(absPath, baseline);
+        result.restored.push(filePath);
+      } catch (error) {
+        result.failed.push({
+          path: filePath,
+          reason: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return result;
+  }
+  async computeFileChange(absPath, baseline) {
+    return await computeTurnTrackerFileChange({
+      cwd: this.config.cwd,
+      absPath,
+      baseline,
+      preferGitDiff: this.config.useGit,
+      canUseGitDiff: await this.isInGitRepo()
+    });
+  }
+  async isInGitRepo() {
+    if (!this.config.useGit) {
+      return false;
+    }
+    if (this.gitDetected !== null) {
+      return this.gitDetected;
+    }
+    return await new Promise((resolvePromise) => {
+      const proc = spawn("git", ["rev-parse", "--git-dir"], {
+        cwd: this.config.cwd,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      proc.on("close", (code2) => {
+        this.gitDetected = code2 === 0;
+        resolvePromise(this.gitDetected);
+      });
+      proc.on("error", () => {
+        this.gitDetected = false;
+        resolvePromise(false);
+      });
+    });
+  }
+};
+function createTurnTracker(config, logger) {
+  return new TurnChangeTracker(config, logger);
+}
+
+// src/intervention/intervention.ts
+var InterventionController = class {
+  /** Immediate interventions — applied at the next step boundary */
+  immediate = [];
+  /** Deferred messages — held until the turn completes */
+  deferred = [];
+  /**
+   * Callback fired when an intervention is wired into a step.
+   * Set by the Agent before starting a chat turn, cleared after.
+   */
+  onApplied;
+  /** Callback fired when a deferred follow-up is queued. */
+  onDeferredQueued;
+  // ---------------------------------------------------------------------------
+  // Immediate interventions (mid-turn redirect)
+  // ---------------------------------------------------------------------------
+  /**
+   * Inject a message at the next LLM step boundary.
+   *
+   * The message is appended as a user message to the conversation
+   * before the next LLM call in the current multi-step turn. The
+   * LLM will see it and can adjust its behavior accordingly.
+   *
+   * Safe to call from any async context while `chat()` is running.
+   * If called when no turn is active, the message will be picked up
+   * by the first step of the next `chat()` call.
+   *
+   * @param message - The user message to inject
+   * @returns Intervention ID for tracking
+   */
+  intervene(message) {
+    const id = crypto.randomUUID();
+    this.immediate.push(
+      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
+    );
+    return id;
+  }
+  /**
+   * Drain and return all pending immediate interventions.
+   * The internal queue is cleared atomically.
+   *
+   * @internal Called by the LLM stream's `prepareStep` hook
+   */
+  drainImmediate() {
+    if (this.immediate.length === 0) return [];
+    return this.immediate.splice(0);
+  }
+  /** Adopt existing immediate interventions without changing their IDs. */
+  adoptImmediate(items) {
+    if (items.length === 0) return;
+    this.immediate.push(...items);
+  }
+  /** Whether there are pending immediate interventions */
+  get hasPending() {
+    return this.immediate.length > 0;
+  }
+  /** Number of pending immediate interventions */
+  get pendingCount() {
+    return this.immediate.length;
+  }
+  // ---------------------------------------------------------------------------
+  // Deferred messages (after-turn follow-ups)
+  // ---------------------------------------------------------------------------
+  /**
+   * Queue a message for after the current turn completes.
+   *
+   * Unlike `intervene()`, this does **not** inject mid-turn. The
+   * message is held and available via `drainDeferred()` after
+   * `chat()` finishes. The consumer decides whether to send it
+   * as a new turn.
+   *
+   * @param message - The message to queue
+   * @returns Intervention ID for tracking
+   */
+  queueNext(message) {
+    const id = crypto.randomUUID();
+    const queued = Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() });
+    this.deferred.push(queued);
+    this.onDeferredQueued?.(queued);
+    return id;
+  }
+  /**
+   * Drain and return all deferred messages.
+   * The internal queue is cleared atomically.
+   */
+  drainDeferred() {
+    if (this.deferred.length === 0) return [];
+    return this.deferred.splice(0);
+  }
+  /** Adopt existing deferred interventions without changing their IDs. */
+  adoptDeferred(items) {
+    if (items.length === 0) return;
+    this.deferred.push(...items);
+  }
+  /** Whether there are deferred messages */
+  get hasDeferred() {
+    return this.deferred.length > 0;
+  }
+  /** Number of deferred messages */
+  get deferredCount() {
+    return this.deferred.length;
+  }
+  // ---------------------------------------------------------------------------
+  // Housekeeping
+  // ---------------------------------------------------------------------------
+  /** Clear all queues (immediate + deferred) */
+  clear() {
+    this.immediate.length = 0;
+    this.deferred.length = 0;
+  }
+  /** Reset the controller for a new turn (clears onApplied, keeps queues) */
+  resetCallbacks() {
+    this.onApplied = void 0;
+    this.onDeferredQueued = void 0;
+  }
+};
+
+// src/agent/runtime-config.ts
+function createAgentToolRecord(tools) {
+  const toolRecord = {};
+  for (const [id, tool] of tools) {
+    toolRecord[id] = tool;
+  }
+  return toolRecord;
+}
+function buildFallbackCompactionSummary(messages) {
+  const excerpt = messages.map((message) => {
+    const role = message.role.toUpperCase();
+    const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+    return `[${role}] ${content}`;
+  }).join("\n\n");
+  const trimmed = excerpt.length > 8e3 ? `${excerpt.slice(0, 8e3)}
+
+...[truncated during compaction]` : excerpt;
+  return trimmed.length > 0 ? trimmed : "Earlier conversation context was compacted.";
+}
+async function compactAgentContext(options) {
+  const { contextManager, sessions, logger } = options;
+  const log = logger ?? silentLogger;
+  const messages = getVisibleSessionMessages(sessions);
+  if (!contextManager.shouldPrune(messages)) {
+    return {
+      removedCount: 0,
+      tokensRemoved: 0,
+      summarized: false,
+      summary: void 0
+    };
+  }
+  const tokensBefore = estimateConversationTokens(messages);
+  let removedCount = 0;
+  let summarized = false;
+  let summary;
+  try {
+    const result = await contextManager.prune(messages);
+    removedCount = result.removedCount;
+    summarized = result.summarized;
+    summary = result.summary;
+  } catch (pruneError) {
+    log.warn("Context compaction LLM summarisation failed, using fallback", {
+      error: pruneError instanceof Error ? pruneError.message : String(pruneError)
+    });
+  }
+  if (removedCount === 0) {
+    removedCount = findCutPoint(
+      messages,
+      contextManager.getLimits().protectedTokens
+    );
+  }
+  if (removedCount === 0) {
+    return {
+      removedCount: 0,
+      tokensRemoved: 0,
+      summarized: false,
+      summary: void 0
+    };
+  }
+  const summaryText = summary ?? buildFallbackCompactionSummary(messages.slice(0, removedCount));
+  const keptMessages = messages.slice(removedCount);
+  const persistedMessages = [
+    {
+      id: "compaction-preview",
+      role: "system",
+      content: `## Previous Conversation Summary
+
+${summaryText}`,
+      createdAt: /* @__PURE__ */ new Date()
+    },
+    ...keptMessages
+  ];
+  const tokensAfter = estimateConversationTokens(persistedMessages);
+  await sessions.replaceWithCompaction({
+    summary: summaryText,
+    messages: keptMessages,
+    tokensBefore,
+    tokensAfter
+  });
+  return {
+    removedCount,
+    tokensRemoved: Math.max(0, tokensBefore - tokensAfter),
+    summarized,
+    summary: summaryText
+  };
+}
+async function buildAgentSystemPrompts(options) {
+  const {
+    config,
+    toolIds,
+    sessionId,
+    override,
+    promptBuilder,
+    middlewareRunner
+  } = options;
+  if (promptBuilder) {
+    const composedPrompt = await promptBuilder.build(
+      {
+        cwd: config.cwd,
+        model: config.model,
+        toolNames: toolIds,
+        ...override ? { override } : {},
+        sessionId
+      },
+      middlewareRunner
+    );
+    return [composedPrompt];
+  }
+  const prompts = [config.systemPrompt];
+  if (override) {
+    prompts.push(override);
+  }
+  return prompts;
+}
+function createAgentTurnRuntimeConfig(options) {
+  const { config, telemetrySettings } = options;
+  return {
+    model: config.model,
+    cwd: config.cwd,
+    ...config.temperature !== void 0 ? { temperature: config.temperature } : {},
+    ...config.topP !== void 0 ? { topP: config.topP } : {},
+    ...config.maxOutputTokens !== void 0 ? { maxOutputTokens: config.maxOutputTokens } : {},
+    maxSteps: config.maxSteps,
+    ...config.doomLoopThreshold !== void 0 ? { doomLoopThreshold: config.doomLoopThreshold } : {},
+    ...config.enforceDoomLoop !== void 0 ? { enforceDoomLoop: config.enforceDoomLoop } : {},
+    ...config.onDoomLoop ? { onDoomLoop: config.onDoomLoop } : {},
+    ...config.contextWindow !== void 0 ? { contextWindow: config.contextWindow } : {},
+    ...options.reserveTokens !== void 0 ? { reserveTokens: options.reserveTokens } : {},
+    ...config.streamProvider ? { streamProvider: config.streamProvider } : {},
+    ...telemetrySettings ? { telemetry: telemetrySettings } : {}
+  };
+}
 
 // src/agent/chat-loop/commit.ts
 function createChatLoopCommitBatchApplier(params) {
@@ -290,18 +1027,29 @@ function createChatLoopCommitBatchApplier(params) {
 
 // src/agent/chat-loop/compaction.ts
 async function runAutoCompaction(params) {
-  const { contextManager, messages } = params;
+  const { contextManager, sessions, logger } = params;
+  const messages = sessions.getMessages();
   if (!contextManager.shouldPrune(messages)) {
     return [];
   }
   const events = [{ type: "status", status: "processing" }];
-  const pruneResult = await contextManager.prune(messages);
-  if (pruneResult.removedCount > 0 || pruneResult.summarized) {
-    const limits = contextManager.getLimits();
-    events.push({
-      type: "context-overflow",
-      inputTokens: estimateConversationTokens(messages),
-      limit: limits.contextWindow - limits.reserveTokens
+  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)
     });
   }
   return events;
@@ -309,49 +1057,14 @@ async function runAutoCompaction(params) {
 
 // src/agent/chat-loop/prompts.ts
 async function buildChatSystemPrompts(params) {
-  const {
-    promptBuilder,
-    middlewareRunner,
-    systemOverride,
-    sessionId,
-    config,
-    tools
-  } = params;
-  if (promptBuilder) {
-    const composedPrompt = await promptBuilder.build(
-      {
-        cwd: config.cwd,
-        model: config.model,
-        toolNames: Object.keys(tools),
-        override: systemOverride,
-        sessionId
-      },
-      middlewareRunner
-    );
-    return [composedPrompt];
-  }
-  const prompts = [config.systemPrompt];
-  if (systemOverride) {
-    prompts.push(systemOverride);
-  }
-  return prompts;
-}
-
-// src/agent/chat-loop/usage.ts
-function accumulateUsage(current, next) {
-  if (!next) return current;
-  if (!current) {
-    return {
-      inputTokens: next.inputTokens ?? 0,
-      outputTokens: next.outputTokens ?? 0,
-      totalTokens: next.totalTokens ?? 0
-    };
-  }
-  return {
-    inputTokens: (current.inputTokens ?? 0) + (next.inputTokens ?? 0),
-    outputTokens: (current.outputTokens ?? 0) + (next.outputTokens ?? 0),
-    totalTokens: (current.totalTokens ?? 0) + (next.totalTokens ?? 0)
-  };
+  return buildAgentSystemPrompts({
+    config: params.config,
+    toolIds: Object.keys(params.tools),
+    sessionId: params.sessionId,
+    override: params.systemOverride,
+    promptBuilder: params.promptBuilder,
+    middlewareRunner: params.middlewareRunner
+  });
 }
 
 // src/agent/chat-loop/loop.ts
@@ -365,11 +1078,12 @@ async function* runChatLoop(deps) {
     (async function* () {
       const {
         sessionId,
+        turnId,
         message,
         abort,
         systemOverride,
         sessions,
-        tools: toolRecord,
+        tools: liveTools,
         config,
         turnTracker,
         interventionCtrl,
@@ -379,10 +1093,13 @@ async function* runChatLoop(deps) {
         reasoningLevel,
         promptBuilder,
         host,
+        humanInputController,
         mcpTools,
         toModelMessages,
         setIsStreaming
       } = deps;
+      let toolRecord = createAgentToolRecord(liveTools);
+      const isPlanMode = deps.toolExecutionMode === "plan";
       const turnEngine = createAgentTurnEngine({
         sessionId,
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -407,20 +1124,24 @@ async function* runChatLoop(deps) {
       let chatOutput;
       try {
         if (middlewareRunner.hasMiddleware) {
-          await middlewareRunner.runChatStart(sessionId, message);
+          await middlewareRunner.runChatStart(sessionId, message, {
+            sessionId,
+            turnId
+          });
         }
-        const systemPrompts = await buildChatSystemPrompts({
-          promptBuilder,
-          middlewareRunner,
-          systemOverride,
-          sessionId,
-          config,
-          tools: toolRecord
-        });
         let step = 1;
         let finalStepText = "";
         let accumulatedUsage;
         while (step <= config.maxSteps) {
+          toolRecord = createAgentToolRecord(liveTools);
+          const systemPrompts = await buildChatSystemPrompts({
+            promptBuilder,
+            middlewareRunner,
+            systemOverride,
+            sessionId,
+            config,
+            tools: toolRecord
+          });
           const preparedStep = prepareModelStep({
             sessionId,
             step,
@@ -432,10 +1153,12 @@ async function* runChatLoop(deps) {
             mcpTools,
             config,
             host,
+            humanInputController,
             turnTracker,
             intervention: interventionCtrl,
             middleware: middlewareRunner,
-            reasoningLevel
+            reasoningLevel,
+            toolExecutionMode: deps.toolExecutionMode
           });
           const stepResult = yield* runModelStep({
             preparedStep,
@@ -448,6 +1171,7 @@ async function* runChatLoop(deps) {
             chatError = stepResult.error;
             return;
           }
+          const planSnapshot = isPlanMode && stepResult.finishReason === "tool-calls" ? turnEngine.createStepCommitSnapshot() : void 0;
           yield* commitStep({
             step,
             finishReason: stepResult.finishReason,
@@ -468,6 +1192,31 @@ async function* runChatLoop(deps) {
               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;
           }
@@ -483,7 +1232,8 @@ async function* runChatLoop(deps) {
         if (config.compaction?.auto !== false) {
           const compactionEvents = await runAutoCompaction({
             contextManager,
-            messages: sessions.getMessages()
+            sessions,
+            logger: deps.logger
           });
           for (const event of compactionEvents) {
             yield event;
@@ -513,6 +1263,12 @@ async function* runChatLoop(deps) {
         };
       } catch (error) {
         chatError = error instanceof Error ? error : new Error(String(error));
+        const statusEvent = { type: "status", status: "error" };
+        middlewareRunner.emitEvent(statusEvent);
+        yield statusEvent;
+        const errorEvent = { type: "error", error: chatError };
+        middlewareRunner.emitEvent(errorEvent);
+        yield errorEvent;
         throw error;
       } finally {
         setIsStreaming(false);
@@ -522,6 +1278,9 @@ async function* runChatLoop(deps) {
             usage: chatUsage,
             error: chatError,
             output: chatOutput
+          }, {
+            sessionId,
+            turnId
           });
         }
       }
@@ -531,10 +1290,10 @@ async function* runChatLoop(deps) {
 
 // src/agent/fork.ts
 function resolveForkOptions(options, parentTools, systemPrompt) {
-  if (!options.preset) {
+  if (!options.profile) {
     return options;
   }
-  const applied = applyPreset(options.preset, parentTools, systemPrompt);
+  const applied = applyProfile(options.profile, parentTools, systemPrompt);
   return {
     ...applied,
     ...options,
@@ -573,6 +1332,9 @@ function createForkedAgentConfig(options) {
     parentTools,
     reasoningLevel,
     host,
+    sandbox,
+    humanInputController,
+    ownsHost,
     sessions,
     mcpManager,
     middlewareRunner,
@@ -588,7 +1350,8 @@ function createForkedAgentConfig(options) {
   return {
     model: forkOptions.model ?? parentConfig.model,
     cwd: parentConfig.cwd,
-    host,
+    ...ownsHost ? {} : sandbox !== void 0 ? { sandbox } : { host },
+    ...humanInputController ? { humanInput: humanInputController } : {},
     maxOutputTokens: parentConfig.maxOutputTokens,
     maxSteps: forkOptions.maxSteps ?? parentConfig.maxSteps,
     temperature: forkOptions.temperature ?? parentConfig.temperature,
@@ -608,7 +1371,7 @@ function createForkedAgentConfig(options) {
 }
 
 // src/agent/mcp-bridge.ts
-async function ensureMcpTools(state) {
+async function ensureMcpTools(state, logger) {
   if (!state.manager) {
     return { connected: false, cachedTools: void 0 };
   }
@@ -618,17 +1381,18 @@ async function ensureMcpTools(state) {
       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") {
-      console.warn(`[mcp] Failed to connect to ${name}: ${status.error}`);
+      log.warn(`Failed to connect to ${name}: ${status.error}`);
     }
   }
   if (connectedCount === 0 && statuses.size > 0) {
-    console.warn("[mcp] No MCP servers connected successfully");
+    log.warn("No MCP servers connected successfully");
   }
   const cachedTools = await state.manager.getTools();
   return {
@@ -646,161 +1410,392 @@ async function closeMcpManager(manager) {
   };
 }
 
-// src/agent/session.ts
-async function ensureSessionLoaded(options) {
-  const { sessionId, sessions, loadedSessions, cwd } = options;
-  if (loadedSessions.has(sessionId) && sessions.getSessionId() === sessionId) {
-    return;
+// 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);
+    };
   }
-  const exists = await sessions.sessionExists(sessionId);
-  if (exists) {
-    await sessions.load(sessionId);
-  } else {
-    await sessions.create({ id: sessionId, cwd });
+  onAny(handler) {
+    this.wildcard.add(handler);
+    return () => {
+      this.wildcard.delete(handler);
+    };
   }
-  loadedSessions.add(sessionId);
-}
-async function repairOrphanedToolCalls(sessions) {
-  const messages = sessions.getMessages();
-  const pendingCallIds = /* @__PURE__ */ new Map();
-  for (const message of messages) {
-    if (message.role === "assistant" && message.toolCalls) {
-      for (const toolCall of message.toolCalls) {
-        pendingCallIds.set(toolCall.toolCallId, { toolName: toolCall.toolName });
+  emit(event) {
+    const set = this.typed.get(event.type);
+    if (set) {
+      for (const fn of set) {
+        try {
+          fn(event);
+        } catch {
+        }
       }
     }
-    if (message.role === "tool" && message.toolCallId) {
-      pendingCallIds.delete(message.toolCallId);
+    for (const fn of this.wildcard) {
+      try {
+        fn(event);
+      } catch {
+      }
     }
   }
-  for (const [toolCallId, { toolName }] of pendingCallIds) {
-    const toolMessage = {
-      id: crypto.randomUUID(),
-      role: "tool",
-      content: "Error: tool execution failed (result was not recorded)",
-      toolCallId,
-      toolName,
-      result: "Error: tool execution failed (result was not recorded)",
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    await sessions.addMessage(toolMessage);
+  clear() {
+    this.typed.clear();
+    this.wildcard.clear();
   }
-}
-async function createSubAgentRunSession(options) {
-  const sessionId = options.parentSessionId ? `${options.parentSessionId}:sub:${crypto.randomUUID().slice(0, 8)}` : `sub:${crypto.randomUUID().slice(0, 8)}`;
-  await options.sessions.create({
-    id: sessionId,
-    cwd: options.cwd,
-    title: options.title ?? "Sub-agent task",
-    parentSessionId: options.parentSessionId
-  });
-  options.loadedSessions.add(sessionId);
-  return sessionId;
-}
+};
 
-// src/agent/intervention.ts
-var InterventionController = class {
-  /** Immediate interventions — applied at the next step boundary */
-  immediate = [];
-  /** Deferred messages — held until the turn completes */
-  deferred = [];
-  /**
-   * Callback fired when an intervention is wired into a step.
-   * Set by the Agent before starting a chat turn, cleared after.
-   */
-  onApplied;
-  // ---------------------------------------------------------------------------
-  // Immediate interventions (mid-turn redirect)
-  // ---------------------------------------------------------------------------
-  /**
-   * Inject a message at the next LLM step boundary.
-   *
-   * The message is appended as a user message to the conversation
-   * before the next LLM call in the current multi-step turn. The
-   * LLM will see it and can adjust its behavior accordingly.
-   *
-   * Safe to call from any async context while `chat()` is running.
-   * If called when no turn is active, the message will be picked up
-   * by the first step of the next `chat()` call.
-   *
-   * @param message - The user message to inject
-   * @returns Intervention ID for tracking
-   */
-  intervene(message) {
-    const id = crypto.randomUUID();
-    this.immediate.push(
-      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
-    );
-    return id;
-  }
-  /**
-   * Drain and return all pending immediate interventions.
-   * The internal queue is cleared atomically.
-   *
-   * @internal Called by the LLM stream's `prepareStep` hook
-   */
-  drainImmediate() {
-    if (this.immediate.length === 0) return [];
-    return this.immediate.splice(0);
+// src/human/controller.ts
+var HumanInputTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Human input request timed out after ${timeoutMs}ms`);
+    this.name = "HumanInputTimeoutError";
   }
-  /** Whether there are pending immediate interventions */
-  get hasPending() {
-    return this.immediate.length > 0;
+};
+var HumanInputUnavailableError = class extends Error {
+  constructor() {
+    super("No human input controller configured");
+    this.name = "HumanInputUnavailableError";
   }
-  /** Number of pending immediate interventions */
-  get pendingCount() {
-    return this.immediate.length;
+};
+function cloneRecord(record) {
+  return structuredClone(record);
+}
+function normalizeStatuses(status) {
+  if (!status) {
+    return void 0;
   }
-  // ---------------------------------------------------------------------------
-  // Deferred messages (after-turn follow-ups)
-  // ---------------------------------------------------------------------------
-  /**
-   * Queue a message for after the current turn completes.
-   *
-   * Unlike `intervene()`, this does **not** inject mid-turn. The
-   * message is held and available via `drainDeferred()` after
-   * `chat()` finishes. The consumer decides whether to send it
-   * as a new turn.
-   *
-   * @param message - The message to queue
-   * @returns Intervention ID for tracking
-   */
-  queueNext(message) {
-    const id = crypto.randomUUID();
-    this.deferred.push(
-      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
-    );
-    return id;
+  return new Set(Array.isArray(status) ? status : [status]);
+}
+function inferKind(input) {
+  if (input.kind) {
+    return input.kind;
   }
-  /**
-   * Drain and return all deferred messages.
-   * The internal queue is cleared atomically.
-   */
-  drainDeferred() {
-    if (this.deferred.length === 0) return [];
-    return this.deferred.splice(0);
+  if (input.options && input.options.length > 0) {
+    return "choice";
   }
-  /** Whether there are deferred messages */
-  get hasDeferred() {
-    return this.deferred.length > 0;
+  return "text";
+}
+function isHumanInputController(value) {
+  if (!value || typeof value !== "object") {
+    return false;
   }
-  /** Number of deferred messages */
-  get deferredCount() {
-    return this.deferred.length;
+  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);
+}
+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
+      });
+    });
+    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;
   }
-  // ---------------------------------------------------------------------------
-  // Housekeeping
-  // ---------------------------------------------------------------------------
-  /** Clear all queues (immediate + deferred) */
-  clear() {
-    this.immediate.length = 0;
-    this.deferred.length = 0;
+  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);
   }
-  /** Reset the controller for a new turn (clears onApplied, keeps queues) */
-  resetCallbacks() {
-    this.onApplied = void 0;
+  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 {
+          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) {
+          if (error instanceof HumanInputUnavailableError) {
+            throw error;
+          }
+          throw error;
+        }
+        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
+      }
+    }
+  );
+}
+var createHumanInputToolWithHandler = createHumanInputToolWithController;
 
 // src/agent/stream-provider.ts
 var DEFAULT_CUSTOM_STREAM_MODELS = [
@@ -808,7 +1803,7 @@ var DEFAULT_CUSTOM_STREAM_MODELS = [
   "computer-use-preview-2025-03-11"
 ];
 function needsCustomStreamProvider(model, customPatterns) {
-  const modelId = getModelId(model);
+  const modelId = extractModelId(model);
   if (!modelId || modelId === "[object Object]") return false;
   const patterns = customPatterns ?? DEFAULT_CUSTOM_STREAM_MODELS;
   return patterns.some((pattern) => modelId.includes(pattern));
@@ -824,7 +1819,7 @@ function autoDetectStreamProvider(model, tools, explicitProvider) {
   const enhancedTools = tools;
   const customPatterns = enhancedTools.__customStreamModels;
   if (needsCustomStreamProvider(model, customPatterns) && hasStreamProviderFactory(enhancedTools)) {
-    const modelId = getModelId(model);
+    const modelId = extractModelId(model);
     if (modelId) {
       const streamConfig = {
         apiKey: process.env.OPENAI_API_KEY,
@@ -838,18 +1833,6 @@ function autoDetectStreamProvider(model, tools, explicitProvider) {
   return void 0;
 }
 
-// src/agent/defaults.ts
-var DEFAULT_SYSTEM_PROMPT = `You are a capable AI assistant with access to tools.
-
-Think step by step about what you need to do.
-Use the available tools to accomplish tasks.
-Verify your results after each action.
-
-If a tool fails, try an alternative approach \u2014 do not give up after a single error.
-Keep working until the task is fully resolved or you have exhausted all options.`;
-var DEFAULT_MAX_STEPS = 50;
-var DEFAULT_MAX_TOKENS = 32e3;
-
 // src/agent/setup.ts
 function createAgentPromptBuilder(config) {
   if (config.prompt !== void 0) {
@@ -866,14 +1849,24 @@ function createEffectiveAgentConfig(config) {
     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 {
-    systemPrompt: DEFAULT_SYSTEM_PROMPT,
-    cwd: process.cwd(),
-    reasoningLevel: "off",
     ...config,
-    // Re-apply defaults after spread so explicit `undefined` from callers doesn't win.
-    maxSteps: config.maxSteps ?? DEFAULT_MAX_STEPS,
-    maxOutputTokens: config.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
+    systemPrompt: config.systemPrompt ?? defaults.systemPrompt,
+    cwd: resolvedCwd,
+    reasoningLevel: config.reasoningLevel ?? "off",
+    maxSteps: config.maxSteps ?? defaults.maxSteps,
+    maxOutputTokens: config.maxOutputTokens ?? defaults.maxOutputTokens,
     streamProvider: effectiveStreamProvider
   };
 }
@@ -892,148 +1885,139 @@ function resolveInitialReasoningLevel(config) {
 function createAgentState(config) {
   return {
     model: config.model,
-    systemPrompt: config.systemPrompt,
-    cwd: config.cwd,
-    isStreaming: false,
     reasoningLevel: resolveInitialReasoningLevel(config)
   };
 }
 function createAgentContextManager(config) {
   const compactionConfig = config.compaction ?? {};
-  const modelId = getModelId(config.model);
+  const modelId = extractModelId(config.model);
   const inferredWindow = inferContextWindow(modelId);
   const contextWindow = config.contextWindow ?? inferredWindow ?? DEFAULT_CONTEXT_LIMITS.contextWindow;
-  const reserveTokens = Math.min(
-    32e3,
-    Math.max(8e3, Math.round(contextWindow * 0.12))
-  );
   return new ContextManager({
     limits: {
       contextWindow,
-      reserveTokens,
-      protectedTokens: compactionConfig.protectedTokens ?? DEFAULT_CONTEXT_LIMITS.protectedTokens,
-      pruneMinimum: compactionConfig.pruneMinimum ?? DEFAULT_CONTEXT_LIMITS.pruneMinimum
+      ...resolveAgentContextLimits(contextWindow, compactionConfig)
     },
     model: compactionConfig.summaryModel ?? config.model,
     summaryPrompt: compactionConfig.summaryPrompt
   });
 }
+function resolveAgentContextLimits(contextWindow, compactionConfig = {}) {
+  const proportionalReserve = Math.round(contextWindow * 0.12);
+  const reserveTokens = contextWindow >= 64e3 ? Math.min(32e3, Math.max(8e3, proportionalReserve)) : Math.min(
+    Math.max(1024, Math.round(contextWindow * 0.25)),
+    Math.max(512, proportionalReserve)
+  );
+  const usableWindow = Math.max(512, 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) {
-  let effectiveMiddleware = input.middleware;
+  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 ?? "agent";
+    const agentName = config.name ?? DEFAULT_AGENT_NAME;
     const telemetryResult = createTelemetryConfig({
+      ...input.tracing,
       agentName,
-      agentDescription: input.tracing.agentDescription,
-      recordInputs: input.tracing.recordInputs,
-      recordOutputs: input.tracing.recordOutputs,
-      emitToolSpans: input.tracing.emitToolSpans,
-      spanTimeoutMs: input.tracing.spanTimeoutMs,
-      spanProcessor: input.tracing.spanProcessor,
       serviceName: input.tracing.serviceName ?? agentName
     });
     effectiveMiddleware = [
       telemetryResult.middleware,
-      ...input.middleware ?? []
+      ...effectiveMiddleware
     ];
     telemetrySettings = telemetryResult.telemetry;
     tracingShutdown = telemetryResult.shutdown;
   }
   return {
-    middlewareRunner: new MiddlewareRunner(effectiveMiddleware),
+    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
+    };
+  }
+  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(),
     state: createAgentState(config),
     contextManager: createAgentContextManager(config),
-    turnTracker: createTurnTracker({ cwd: config.cwd }),
+    turnTracker: createTurnTracker({ cwd: config.cwd }, logger),
     ...input.mcp ? { mcpManager: input.mcp } : {},
     ...promptBuilder ? { promptBuilder } : {},
     interventionCtrl: new InterventionController(),
-    host: input.host ?? localHost(config.cwd),
+    ...humanInputSetup,
+    ...executionEnvironment,
     middlewareRunner: middlewareSetup.middlewareRunner,
+    logger,
     ...middlewareSetup.telemetrySettings ? { telemetrySettings: middlewareSetup.telemetrySettings } : {},
     ...middlewareSetup.tracingShutdown ? { tracingShutdown: middlewareSetup.tracingShutdown } : {}
   };
 }
 
-// src/agent/runtime-config.ts
-function createAgentToolRecord(tools) {
-  const toolRecord = {};
-  for (const [id, tool] of tools) {
-    toolRecord[id] = tool;
-  }
-  return toolRecord;
-}
-function getAgentContextStats(contextManager, messages) {
-  return contextManager.getStats(messages);
-}
-async function compactAgentContext(contextManager, messages) {
-  const result = await contextManager.prune(messages);
-  return {
-    removedCount: result.removedCount,
-    tokensRemoved: result.tokensRemoved,
-    summarized: result.summarized,
-    summary: result.summary
-  };
-}
-async function buildAgentSystemPrompts(options) {
-  const {
-    config,
-    toolIds,
-    sessionId,
-    override,
-    promptBuilder,
-    middlewareRunner
-  } = options;
-  if (promptBuilder) {
-    const composedPrompt = await promptBuilder.build(
-      {
-        cwd: config.cwd,
-        model: config.model,
-        toolNames: toolIds,
-        ...override ? { override } : {},
-        sessionId
-      },
-      middlewareRunner
-    );
-    return [composedPrompt];
-  }
-  const prompts = [config.systemPrompt];
-  if (override) {
-    prompts.push(override);
-  }
-  return prompts;
-}
-function createAgentTurnRuntimeConfig(options) {
-  const { config, telemetrySettings } = options;
-  return {
-    model: config.model,
-    cwd: config.cwd,
-    ...config.temperature !== void 0 ? { temperature: config.temperature } : {},
-    ...config.topP !== void 0 ? { topP: config.topP } : {},
-    ...config.maxOutputTokens !== void 0 ? { maxOutputTokens: config.maxOutputTokens } : {},
-    maxSteps: config.maxSteps,
-    ...config.doomLoopThreshold !== void 0 ? { doomLoopThreshold: config.doomLoopThreshold } : {},
-    ...config.enforceDoomLoop !== void 0 ? { enforceDoomLoop: config.enforceDoomLoop } : {},
-    ...config.onDoomLoop ? { onDoomLoop: config.onDoomLoop } : {},
-    ...config.contextWindow !== void 0 ? { contextWindow: config.contextWindow } : {},
-    ...config.streamProvider ? { streamProvider: config.streamProvider } : {},
-    ...telemetrySettings ? { telemetry: telemetrySettings } : {}
-  };
-}
-
 // src/agent/instance.ts
 function createAgent(config) {
   return new Agent(config);
@@ -1042,7 +2026,6 @@ var Agent = class _Agent {
   config;
   tools;
   sessions;
-  loadedSessions = /* @__PURE__ */ new Set();
   state;
   /** Context manager for overflow detection and compaction */
   contextManager;
@@ -1066,6 +2049,12 @@ var Agent = class _Agent {
   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 */
+  ownsHost;
   /** Middleware runner for lifecycle hooks */
   middlewareRunner;
   /** AI SDK telemetry settings (auto-created from `tracing` config) */
@@ -1074,6 +2063,14 @@ var Agent = class _Agent {
   tracingShutdown;
   /** Multi-consumer event dispatch */
   _signal;
+  /** Number of active turns across all sessions */
+  activeTurnCount = 0;
+  /** Active turn intervention controllers, keyed by turn id */
+  activeTurns = /* @__PURE__ */ new Map();
+  /** Per-session turn queue to prevent concurrent writes to the same history */
+  sessionLocks = /* @__PURE__ */ new Map();
+  /** Structured logger for diagnostic output */
+  _logger;
   constructor(config) {
     const setup = createAgentSetup(config);
     this.config = setup.config;
@@ -1086,7 +2083,11 @@ var Agent = class _Agent {
     this.promptBuilder = setup.promptBuilder;
     this.interventionCtrl = setup.interventionCtrl;
     this.host = setup.host;
+    this.sandbox = setup.sandbox;
+    this.humanInputController = setup.humanInputController;
+    this.ownsHost = setup.ownsHost;
     this.middlewareRunner = setup.middlewareRunner;
+    this._logger = setup.logger;
     this.telemetrySettings = setup.telemetrySettings;
     this.tracingShutdown = setup.tracingShutdown;
     this._signal = config.signal ?? new LocalSignal();
@@ -1101,9 +2102,13 @@ var Agent = class _Agent {
   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 ?? "agent";
+    return this.config.name ?? DEFAULT_AGENT_NAME;
   }
   /** Working directory for file operations */
   get cwd() {
@@ -1119,7 +2124,7 @@ var Agent = class _Agent {
   }
   /** Is currently streaming */
   get isStreaming() {
-    return this.state.isStreaming;
+    return this.activeTurnCount > 0;
   }
   /** Current reasoning level */
   get reasoningLevel() {
@@ -1162,6 +2167,96 @@ var Agent = class _Agent {
       }
     }
   }
+  resetPromptScopedTools() {
+    this.tools.delete("skill");
+    this.tools.delete("skill_resource");
+    this.skillToolsResolved = false;
+  }
+  createSessionManager() {
+    return new SessionManager(this.sessions.getStorage());
+  }
+  async acquireSessionLock(sessionId) {
+    const previous = this.sessionLocks.get(sessionId) ?? Promise.resolve();
+    let releaseLock;
+    const current = new Promise((resolve2) => {
+      releaseLock = resolve2;
+    });
+    const chain = previous.catch(() => void 0).then(() => current);
+    this.sessionLocks.set(sessionId, chain);
+    await previous.catch(() => void 0);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      releaseLock();
+      if (this.sessionLocks.get(sessionId) === chain) {
+        this.sessionLocks.delete(sessionId);
+      }
+    };
+  }
+  /**
+   * 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.sessionLocks.delete(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;
+  }
+  createTurnInterventionController() {
+    return this.activeTurns.size === 0 ? this.interventionCtrl : new InterventionController();
+  }
+  releaseTurnInterventions(controller) {
+    if (controller === this.interventionCtrl) {
+      controller.resetCallbacks();
+      return;
+    }
+    this.interventionCtrl.adoptImmediate(controller.drainImmediate());
+    this.interventionCtrl.adoptDeferred(controller.drainDeferred());
+    controller.resetCallbacks();
+  }
+  syncStreamingState(active) {
+    this.activeTurnCount = Math.max(
+      0,
+      this.activeTurnCount + (active ? 1 : -1)
+    );
+  }
+  async syncSessionView(sessionId) {
+    if (!await this.sessions.sessionExists(sessionId)) {
+      return;
+    }
+    await this.sessions.load(sessionId);
+  }
   /**
    * Ensure MCP is connected and return tools
    * Lazy initialization - only connects on first use
@@ -1171,34 +2266,11 @@ var Agent = class _Agent {
       manager: this.mcpManager,
       connected: this.mcpConnected,
       cachedTools: this.mcpToolsCache
-    });
+    }, this._logger);
     this.mcpConnected = nextState.connected;
     this.mcpToolsCache = nextState.cachedTools;
     return nextState.cachedTools ?? {};
   }
-  /**
-   * Repair session history by synthesising missing tool-result messages.
-   *
-   * When a tool `execute()` throws, the AI SDK emits `tool-error` instead
-   * of `tool-result`. If the error event wasn't persisted (e.g. because
-   * the fix above wasn't in place), subsequent turns will fail with
-   * `MissingToolResultsError`. This method detects orphaned tool-call IDs
-   * and adds placeholder `tool` messages so the history is valid again.
-   */
-  async repairOrphanedToolCalls() {
-    await repairOrphanedToolCalls(this.sessions);
-  }
-  /**
-   * Convert internal {@link Message} array to Vercel AI SDK {@link ModelMessage} format.
-   *
-   * Handles the role-specific mappings:
-   * - `user` / `system` → pass-through
-   * - `assistant` with tool calls → `ToolCallPart[]` content
-   * - `tool` → `tool-result` content part
-   */
-  toModelMessages(messages) {
-    return convertAgentMessagesToModelMessages(messages);
-  }
   /**
    * Stream a chat response.
    *
@@ -1212,52 +2284,79 @@ var Agent = class _Agent {
    * @yields {AgentEvent} Events as they occur during processing
    */
   async *chat(sessionId, message, options) {
-    await this.ensureSession(sessionId);
-    await this.ensureSkillTools();
-    const abort = options?.abort ?? new AbortController().signal;
+    const releaseSessionLock = await this.acquireSessionLock(sessionId);
+    const sessions = this.createSessionManager();
     const turnId = `${sessionId}-turn-${++this.turnCounter}`;
-    this.turnTracker.startTurn(turnId);
-    await this.repairOrphanedToolCalls();
-    const mcpTools = await this.ensureMCPConnected();
-    const loop = runChatLoop({
-      sessionId,
-      message,
-      abort,
-      systemOverride: options?.system,
-      sessions: this.sessions,
-      tools: createAgentToolRecord(this.tools),
-      config: this.config,
-      turnTracker: this.turnTracker,
-      interventionCtrl: this.interventionCtrl,
-      middlewareRunner: this.middlewareRunner,
-      contextManager: this.contextManager,
-      rememberedDoomLoopTools: this.rememberedDoomLoopTools,
-      reasoningLevel: this.state.reasoningLevel,
-      promptBuilder: this.promptBuilder,
-      host: this.host,
-      mcpTools,
-      telemetrySettings: this.telemetrySettings,
-      toModelMessages: this.toModelMessages.bind(this),
-      setIsStreaming: (v) => {
-        this.state.isStreaming = v;
+    let turnTracker;
+    let interventionCtrl = this.interventionCtrl;
+    let streamingStateActive = false;
+    let turnRegistered = false;
+    try {
+      await this.ensureSkillTools();
+      const abort = options?.abort ?? new AbortController().signal;
+      turnTracker = createTurnTracker({ cwd: this.config.cwd });
+      interventionCtrl = this.createTurnInterventionController();
+      this.activeTurns.set(turnId, { sessionId, interventionCtrl });
+      turnRegistered = true;
+      await ensureSessionLoaded({
+        sessionId,
+        sessions,
+        cwd: this.config.cwd
+      });
+      turnTracker.startTurn(turnId);
+      await repairOrphanedToolCalls(sessions);
+      const mcpTools = await this.ensureMCPConnected();
+      const loop = runChatLoop({
+        sessionId,
+        turnId,
+        message,
+        abort,
+        systemOverride: options?.system,
+        sessions,
+        tools: this.tools,
+        config: this.config,
+        turnTracker,
+        interventionCtrl,
+        middlewareRunner: this.middlewareRunner,
+        contextManager: this.contextManager,
+        rememberedDoomLoopTools: this.rememberedDoomLoopTools,
+        reasoningLevel: this.state.reasoningLevel,
+        promptBuilder: this.promptBuilder,
+        host: this.host,
+        humanInputController: this.humanInputController,
+        mcpTools,
+        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;
+        }
+        await this.syncSessionView(sessionId);
+      } finally {
+        releaseSessionLock();
       }
-    });
-    for await (const event of loop) {
-      this._signal.emit(event);
-      yield event;
     }
   }
-  /**
-   * Ensure a session is loaded or created
-   */
-  async ensureSession(sessionId) {
-    await ensureSessionLoaded({
-      sessionId,
-      sessions: this.sessions,
-      loadedSessions: this.loadedSessions,
-      cwd: this.config.cwd
-    });
-  }
   /**
    * Send a message and wait for the complete response (non-streaming).
    *
@@ -1326,13 +2425,20 @@ var Agent = class _Agent {
   getSessionContext() {
     return this.sessions.getContext();
   }
-  /** Get messages from current session */
+  /**
+   * 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) {
-    this.loadedSessions.delete(sessionId);
     return this.sessions.deleteSession(sessionId);
   }
   /** List all sessions */
@@ -1368,8 +2474,7 @@ var Agent = class _Agent {
    * ```
    */
   getContextStats() {
-    return getAgentContextStats(
-      this.contextManager,
+    return this.contextManager.getStats(
       this.sessions.getMessages()
     );
   }
@@ -1382,10 +2487,11 @@ var Agent = class _Agent {
    * @returns Pruning result with details about what was removed/summarized
    */
   async compactContext() {
-    return await compactAgentContext(
-      this.contextManager,
-      this.sessions.getMessages()
-    );
+    return await compactAgentContext({
+      contextManager: this.contextManager,
+      sessions: this.sessions,
+      logger: this._logger
+    });
   }
   /**
    * Clear remembered doom loop tools.
@@ -1415,6 +2521,8 @@ var Agent = class _Agent {
    *
    * If called when no turn is active, the message will be picked up
    * by the first step of the next `chat()` call.
+   * If multiple turns are active concurrently, this throws because the
+   * target turn would be ambiguous.
    *
    * @param message - The user message to inject mid-turn
    * @returns Intervention ID for tracking
@@ -1436,7 +2544,7 @@ var Agent = class _Agent {
    * ```
    */
   intervene(message) {
-    return this.interventionCtrl.intervene(message);
+    return this.getInterventionControllerForTurn().intervene(message);
   }
   /**
    * Queue a message for after the current turn completes.
@@ -1446,6 +2554,9 @@ var Agent = class _Agent {
    * `chat()` finishes. The consumer decides whether to send it as a
    * new turn.
    *
+   * If multiple turns are active concurrently, this throws because the
+   * target turn would be ambiguous.
+   *
    * @param message - The message to queue
    * @returns Intervention ID for tracking
    *
@@ -1468,15 +2579,15 @@ var Agent = class _Agent {
    * ```
    */
   queueNext(message) {
-    return this.interventionCtrl.queueNext(message);
+    return this.getInterventionControllerForTurn().queueNext(message);
   }
   /** Whether there are deferred messages queued for after the turn */
   hasQueuedNext() {
-    return this.interventionCtrl.hasDeferred;
+    return this.getInterventionControllerForTurn().hasDeferred;
   }
   /** Drain and return all deferred messages (clears the queue) */
   drainQueuedNext() {
-    return this.interventionCtrl.drainDeferred();
+    return this.getInterventionControllerForTurn().drainDeferred();
   }
   /**
    * Get the raw intervention controller for advanced use cases.
@@ -1488,7 +2599,7 @@ var Agent = class _Agent {
    * @internal
    */
   getInterventionController() {
-    return this.interventionCtrl;
+    return this.getInterventionControllerForTurn();
   }
   // ============================================================================
   // Turn Tracking
@@ -1563,28 +2674,37 @@ var Agent = class _Agent {
    */
   setSystemPrompt(prompt) {
     this.config.systemPrompt = prompt;
-    this.state.systemPrompt = prompt;
     this.promptBuilder = void 0;
+    this.resetPromptScopedTools();
   }
   /** Update working directory */
   setCwd(cwd) {
     this.config.cwd = cwd;
-    this.state.cwd = cwd;
+    this.turnTracker = createTurnTracker({ cwd });
+    if (this.ownsHost) {
+      this.host = localHost(cwd);
+    }
+    this.resetPromptScopedTools();
     this.promptBuilder?.clearCache();
   }
   /** Update model */
   setModel(model) {
     this.config.model = model;
     this.state.model = model;
+    if (this.config.compaction?.summaryModel === void 0) {
+      this.contextManager.setModel(model);
+    }
     if (this.config.contextWindow === void 0) {
-      const modelId = getModelId(model);
+      const modelId = extractModelId(model);
       const inferred = inferContextWindow(modelId);
       if (inferred) {
-        const reserveTokens = Math.min(
-          32e3,
-          Math.max(8e3, Math.round(inferred * 0.12))
-        );
-        this.contextManager.setLimits({ contextWindow: inferred, reserveTokens });
+        this.contextManager.setLimits({
+          contextWindow: inferred,
+          ...resolveAgentContextLimits(
+            inferred,
+            this.config.compaction
+          )
+        });
       }
     }
   }
@@ -1624,6 +2744,7 @@ var Agent = class _Agent {
    * runtimes can start durable turns without duplicating prompt assembly.
    */
   async buildSystemPrompts(sessionId, override) {
+    await this.ensureSkillTools();
     return await buildAgentSystemPrompts({
       config: this.config,
       toolIds: Array.from(this.tools.keys()),
@@ -1640,7 +2761,8 @@ var Agent = class _Agent {
   getTurnRuntimeConfig() {
     return createAgentTurnRuntimeConfig({
       config: this.config,
-      telemetrySettings: this.telemetrySettings
+      telemetrySettings: this.telemetrySettings,
+      reserveTokens: this.contextManager.getLimits().reserveTokens
     });
   }
   /**
@@ -1649,6 +2771,26 @@ var Agent = class _Agent {
   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.
+   */
+  hasHumanInputTools() {
+    return [...this.tools.values()].some(
+      (tool) => tool.capabilitiesHint?.humanInput === true
+    );
+  }
   /**
    * Get the configured middleware runner.
    *
@@ -1658,6 +2800,18 @@ var Agent = class _Agent {
   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)
   // ============================================================================
@@ -1699,6 +2853,9 @@ var Agent = class _Agent {
         parentTools: Array.from(this.tools.values()),
         reasoningLevel: this.state.reasoningLevel,
         host: this.host,
+        sandbox: this.sandbox,
+        humanInputController: this.humanInputController,
+        ownsHost: this.ownsHost,
         sessions: this.sessions,
         mcpManager: this.mcpManager,
         middlewareRunner: this.middlewareRunner,
@@ -1707,29 +2864,29 @@ var Agent = class _Agent {
     );
   }
   /**
-   * Create a sub-agent with a preset configuration.
+   * Create a sub-agent with a profile.
    *
-   * Convenience method that applies a preset and returns a forked agent.
+   * Convenience method that applies a profile and returns a forked agent.
    *
    * @example
    * ```typescript
-   * import { Presets } from "@cuylabs/agent-core";
+   * import { Profiles } from "@cuylabs/agent-core";
    *
    * // Create an exploration sub-agent
-   * const explorer = agent.withPreset(Presets.explore);
+   * 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.withPreset(Presets.review);
+   * const reviewer = agent.withProfile(Profiles.review);
    * const review = await reviewer.run({
    *   message: "Review src/auth.ts for security issues",
    * });
    * ```
    */
-  withPreset(preset) {
-    return this.fork({ preset });
+  withProfile(profile) {
+    return this.fork({ profile });
   }
   /**
    * Run a task in an isolated sub-agent session.
@@ -1750,9 +2907,9 @@ var Agent = class _Agent {
    * ```
    */
   async run(options) {
+    const sessions = this.createSessionManager();
     const sessionId = await createSubAgentRunSession({
-      sessions: this.sessions,
-      loadedSessions: this.loadedSessions,
+      sessions,
       cwd: this.config.cwd,
       parentSessionId: options.parentSessionId,
       title: options.title
@@ -1805,6 +2962,7 @@ var Agent = class _Agent {
    */
   async close() {
     this._signal.clear();
+    this.humanInputController?.cancelAll("Agent closed");
     if (this.tracingShutdown) {
       await this.tracingShutdown();
     }
@@ -1814,29 +2972,243 @@ var Agent = class _Agent {
   }
 };
 
-// src/agent/concurrent.ts
-async function runConcurrent(tasks, options) {
-  const maxConcurrency = options?.maxConcurrency ?? 5;
-  const results = new Array(tasks.length);
-  let currentIndex = 0;
-  async function runNext() {
-    while (currentIndex < tasks.length) {
-      const index = currentIndex++;
-      const task = tasks[index];
-      results[index] = await task.agent.run({
-        parentSessionId: task.parentSessionId,
-        message: task.message,
-        title: task.title,
-        abort: options?.abort
-      });
+// src/agent/event-printer.ts
+function createEventPrinter(options = {}) {
+  const {
+    tools = true,
+    reasoning = true,
+    steps = false,
+    safety = true,
+    completion = true,
+    team = false,
+    stdout = process.stdout,
+    stderr = process.stderr
+  } = options;
+  return (event) => {
+    switch (event.type) {
+      // ── Lifecycle ─────────────────────────────────────────────────
+      case "status":
+        if (steps) stderr.write(`\u23F3 Status \u2192 ${event.status}
+`);
+        break;
+      case "step-start":
+        if (steps) stderr.write(`\u{1F4CD} Step ${event.step}/${event.maxSteps}
+`);
+        break;
+      case "step-finish":
+        break;
+      // silent by default
+      case "turn-boundary":
+        if (steps) stderr.write(`\u{1F9F1} Boundary \u2192 ${event.boundary}
+`);
+        break;
+      // ── Text streaming ────────────────────────────────────────────
+      case "text-start":
+        break;
+      // cursor is already in place
+      case "text-delta":
+        stdout.write(event.text);
+        break;
+      case "text-end":
+        stdout.write("\n");
+        break;
+      // ── Messages ──────────────────────────────────────────────────
+      case "message":
+        break;
+      // too noisy for CLI output
+      // ── Reasoning ─────────────────────────────────────────────────
+      case "reasoning-start":
+        if (reasoning) stderr.write("\u{1F4AD} ");
+        break;
+      case "reasoning-delta":
+        if (reasoning) stderr.write(event.text);
+        break;
+      case "reasoning-end":
+        if (reasoning) stderr.write("\n");
+        break;
+      // ── Tool execution ────────────────────────────────────────────
+      case "tool-start":
+        if (tools)
+          stderr.write(
+            `\u{1F527} ${event.toolName}(${JSON.stringify(event.input)})
+`
+          );
+        break;
+      case "tool-result":
+        if (tools)
+          stderr.write(`   \u2713 ${String(event.result).slice(0, 200)}
+`);
+        break;
+      case "tool-error":
+        if (tools) stderr.write(`   \u2717 ${event.error}
+`);
+        break;
+      // ── Approval / intervention ───────────────────────────────────
+      case "approval-request":
+        if (safety)
+          stderr.write(
+            `\u{1F6C2} Approval needed \u2192 ${event.request.tool} [${event.request.risk}]
+`
+          );
+        break;
+      case "approval-resolved":
+        if (safety)
+          stderr.write(`\u{1F6C2} Approval ${event.id} \u2192 ${event.action}
+`);
+        break;
+      case "intervention-applied":
+        if (safety)
+          stderr.write(`\u270B Intervention \u2192 ${event.message}
+`);
+        break;
+      case "follow-up-queued":
+        if (safety)
+          stderr.write(`\u{1F4CC} Follow-up queued \u2192 ${event.message}
+`);
+        break;
+      // ── Safety ────────────────────────────────────────────────────
+      case "doom-loop":
+        if (safety)
+          stderr.write(
+            `\u26A0\uFE0F  Doom loop: ${event.toolName} repeated ${event.repeatCount}x
+`
+          );
+        break;
+      case "context-overflow":
+        if (safety)
+          stderr.write(
+            `\u26A0\uFE0F  Context overflow: ${event.inputTokens}/${event.limit} tokens
+`
+          );
+        break;
+      case "turn-summary":
+        if (safety)
+          stderr.write(
+            `\u{1F5C2}\uFE0F  Turn summary \u2192 ${event.files.length} file(s), +${event.additions}/-${event.deletions}
+`
+          );
+        break;
+      // ── Computer use ──────────────────────────────────────────────
+      case "computer-call":
+        if (tools)
+          stderr.write(`\u{1F5A5}\uFE0F  Computer action \u2192 ${event.callId}
+`);
+        break;
+      case "computer-result":
+        if (tools)
+          stderr.write(`\u{1F5A5}\uFE0F  Computer result \u2192 ${event.callId}
+`);
+        break;
+      // ── Human input ───────────────────────────────────────────────
+      case "human-input-request":
+        if (safety)
+          stderr.write(
+            `\u2753 ${event.request.title}: ${event.request.question}
+`
+          );
+        break;
+      case "human-input-resolved":
+        break;
+      // host handles display
+      // ── Error & retry ─────────────────────────────────────────────
+      case "retry":
+        stderr.write(
+          `\u{1F501} Retry ${event.attempt} in ${event.delayMs}ms
+`
+        );
+        break;
+      case "error":
+        stderr.write(`\u274C ${event.error.message}
+`);
+        break;
+      // ── Completion ────────────────────────────────────────────────
+      case "complete":
+        if (completion)
+          stderr.write(
+            `\u2705 Done \u2014 ${event.usage?.totalTokens ?? "?"} tokens
+`
+          );
+        break;
+      // ── Team events ───────────────────────────────────────────────
+      default:
+        if (team && "type" in event && event.type.startsWith("team-")) {
+          printTeamEvent(stderr, event);
+        }
+        break;
     }
+  };
+}
+function printTeamEvent(out, event) {
+  switch (event.type) {
+    case "team-started":
+      out.write(`\u{1F3C1} Team started
+`);
+      break;
+    case "team-member-registered":
+      out.write(
+        `  \u{1F464} ${event.member.id} (${event.member.role})
+`
+      );
+      break;
+    case "team-task-completed":
+      out.write(
+        `  \u2705 Task ${event.taskId} completed
+`
+      );
+      break;
+    case "team-task-failed":
+      out.write(
+        `  \u274C Task ${event.taskId} failed
+`
+      );
+      break;
+    case "team-stopped":
+      out.write(`\u{1F3C1} Team stopped
+`);
+      break;
   }
-  const workers = Array.from(
-    { length: Math.min(maxConcurrency, tasks.length) },
-    () => runNext()
-  );
-  await Promise.all(workers);
-  return results;
+}
+
+// src/intervention/follow-up-policy.ts
+function normalizeFollowUpMode(mode) {
+  return mode ?? "suggest";
+}
+function createQueuedFollowUpRecord(request, options = {}) {
+  const createdAt = options.createdAt ?? new Date(request.timestamp).toISOString();
+  return {
+    id: request.id,
+    sessionId: request.sessionId,
+    message: request.message,
+    createdAt,
+    updatedAt: options.updatedAt ?? createdAt,
+    mode: normalizeFollowUpMode(options.mode),
+    status: "queued",
+    ...options.sourceTurnId ? { sourceTurnId: options.sourceTurnId } : {},
+    ...options.workflowInstanceId ? { workflowInstanceId: options.workflowInstanceId } : {}
+  };
+}
+function resolveQueuedFollowUp(record, action, updatedAt) {
+  return {
+    ...record,
+    status: action === "accept" ? "accepted" : "discarded",
+    updatedAt,
+    decidedAt: updatedAt
+  };
+}
+function markQueuedFollowUpApplied(record, updatedAt, seededTurnId) {
+  return {
+    ...record,
+    status: "applied",
+    updatedAt,
+    appliedAt: updatedAt,
+    ...seededTurnId ? { seededTurnId } : {}
+  };
+}
+function canSeedQueuedFollowUp(record) {
+  if (record.status === "accepted") {
+    return true;
+  }
+  return record.status === "queued" && record.mode === "auto-run";
 }
 export {
   Agent,
@@ -1847,37 +3219,49 @@ export {
   CapabilityCache,
   ContextManager,
   ContextOverflowError,
+  DEFAULT_AGENT_NAME,
   DEFAULT_CONTEXT_LIMITS,
+  DEFAULT_DISPATCH_TOOL_IDS,
   DEFAULT_EXTERNAL_DIRS,
   DEFAULT_INSTRUCTION_PATTERNS,
-  DEFAULT_MAX_CONCURRENT,
+  DEFAULT_LOCAL_DISPATCH_CONCURRENCY,
+  DEFAULT_LOCAL_DISPATCH_DEPTH,
+  DEFAULT_LOCAL_DISPATCH_TITLE_PREFIX,
   DEFAULT_MAX_DEPTH,
   DEFAULT_MAX_FILE_SIZE,
-  DEFAULT_MAX_OUTPUT_TOKENS,
+  DEFAULT_MAX_TOKENS as DEFAULT_MAX_OUTPUT_TOKENS,
   DEFAULT_MAX_SCAN_DEPTH,
-  DEFAULT_MAX_SPAWN_DEPTH,
   DEFAULT_MAX_STEPS,
   DEFAULT_MAX_TOKENS,
   DEFAULT_RESOLVER_OPTIONS,
   DEFAULT_RETRY_CONFIG,
-  DEFAULT_SESSION_TITLE_PREFIX,
   DEFAULT_SKILL_MAX_SIZE,
+  DEFAULT_SUBAGENT_CONCURRENCY,
+  DEFAULT_SUBAGENT_DEPTH,
+  DEFAULT_SUBAGENT_SESSION_PREFIX,
   DEFAULT_SYSTEM_PROMPT,
+  DISPATCH_STATES,
   DoomLoopError,
   EXTENDED_LEVELS,
   FIXED_LEVELS,
   FileStorage,
+  HumanInputTimeoutError,
+  HumanInputUnavailableError,
+  InMemoryMailboxStore,
+  InMemoryTaskBoardStore,
   Inference,
   InterventionController,
-  LLM,
   LLMError,
+  LOCAL_SUBAGENT_BACKEND,
+  LayeredSettings,
   LocalSignal,
   MAX_BYTES,
   MAX_LINES,
+  Mailbox,
   MemoryStorage,
   MiddlewareRunner,
   ModelCapabilityResolver,
-  OUTPUT_TOKEN_MAX,
+  NullSettings,
   PRIORITY_BASE,
   PRIORITY_CUSTOM,
   PRIORITY_ENVIRONMENT,
@@ -1886,37 +3270,54 @@ export {
   PRIORITY_SKILLS,
   PRUNE_PROTECTED_TOOLS,
   PatternCapabilitySource,
-  Presets,
+  PluginEventBus,
+  PluginRegistry,
+  Profiles,
   PromptBuilder,
   RemoteCapabilityFetcher,
   RemoteCapabilitySource,
   SKILL_FILENAME,
   STANDARD_LEVELS,
   STORAGE_VERSION,
+  SUBAGENT_TOOL_IDS,
   SessionManager,
   SkillRegistry,
   SourcePriority,
-  SubAgentTracker,
-  TRUNCATE_DIR,
-  TRUNCATE_GLOB,
+  StaticSettings,
+  TERMINAL_STATUSES,
+  TaskBoard,
+  TaskConflictError,
+  TeamCoordinator,
   Tool,
+  ToolHostRegistry,
   ToolRegistry,
   TurnChangeTracker,
+  ValidatedSettings,
+  accumulateUsage,
+  addTokenUsage,
   advanceAgentTurnState,
+  allApprovalConditions,
+  anyApprovalConditions,
   applyAgentWorkflowCommitResult,
   applyAgentWorkflowModelStepResult,
   applyAgentWorkflowToolBatchResult,
   applyAgentWorkflowToolCallResult,
   applyCapabilityOverride,
-  applyPreset,
+  applyProfile,
+  applyWorkflowInterventions,
   approvalMiddleware,
+  approvalRequestsOverlap,
   autoDetectStreamProvider,
   buildAnthropicOptions,
+  buildApprovalRuleContext,
   buildBedrockOptions,
+  buildCoordinatorNotificationEvent,
+  buildCoordinatorSystemPrompt,
   buildEntryPath,
   buildGoogleOptions,
   buildGroqOptions,
   buildMessagesFromEntries,
+  buildModelCallContext,
   buildOpenAIOptions,
   buildOpenRouterOptions,
   buildReasoningOptions,
@@ -1924,55 +3325,95 @@ export {
   buildToolSet,
   buildXAIOptions,
   calculateDelay,
+  canSeedQueuedFollowUp,
   careful,
-  clearCheckpoints,
+  clearInstalledSubAgents,
   cloneAgentWorkflowTurnState,
   code,
   commitOutput,
   commitStep,
   configureDefaultSessionManager,
   configureResolver,
+  configureSubAgents,
   convertAgentMessagesToModelMessages,
+  coordinatorToolDescriptions,
   createAgent,
   createAgentTaskRunner,
   createAgentTurnEngine,
   createAgentTurnState,
   createAgentTurnStepCommitBatch,
   createAgentWorkflowTurnState,
+  createApprovalCorrection,
   createApprovalHandler,
-  createCheckpointManager,
+  createApprovalPolicyPreset,
+  createCloseAgentTool,
+  createCompositeDispatchTaskExecutor,
+  createConditionalApprovalRule,
+  createConsoleLogger,
+  createDangerouslyAllowAllApprovalPolicy,
+  createDispatchExternalTaskControl,
+  createDispatchTaskExecutor,
+  createDispatchTools,
+  createEventBus,
+  createEventPrinter,
+  createFileLogger,
+  createHeadlessDenyApprovalPolicy,
+  createHumanInputController,
+  createHumanInputHandler,
+  createHumanInputTool,
+  createHumanInputToolWithController,
+  createHumanInputToolWithHandler,
+  createInteractiveApprovalPolicy,
+  createInvokeAgentTool,
+  createLocalDispatchRuntime,
   createMCPManager,
   createMessageEntry,
   createMetadataEntry,
-  createPreset,
+  createProfile,
   createPromptBuilder,
+  createQueuedFollowUpRecord,
+  createRememberedApprovalRules,
   createResolver,
   createRetryHandler,
   createRetryState,
-  createScope,
+  createRiskTierApprovalPolicy,
+  createRuntimeDispatchExecutor,
+  createRuntimeDispatchTargets,
   createSkillRegistry,
   createSkillResourceTool,
   createSkillTool,
   createSkillTools,
   createSubAgentTools,
+  createTeamCoordinator,
   createTelemetryConfig,
+  createThresholdApprovalRule,
+  createToolSearchTool,
+  createTrustedSessionApprovalPolicy,
   createTurnTracker,
+  createWaitAgentTool,
   currentScope,
   defaultAgentTaskCheckpointStrategy,
   defaultRegistry,
-  defineServer,
-  defineTool,
+  defaultToolHostRegistry,
+  definePlugin,
+  describeApprovalOperation,
   deserializeMessage,
   detectModelFamily,
   discoverInstructions,
+  discoverPlugins,
   discoverSkills,
-  dockerHost,
+  discoverSubAgentRoles,
+  drainWorkflowInterventions,
   emptySkillRegistry,
+  ensureNonEmpty,
+  ensureSessionLoaded,
   estimateConversationTokens,
   estimateMessageTokens,
   estimateTokens,
+  evaluateCoordinatorRoundTransition,
   executeAgentToolCall,
   explore,
+  extractApprovalPatterns,
   extractFilePathsFromArgs,
   extractModelId,
   extractProvider,
@@ -1982,76 +3423,123 @@ export {
   filterTools,
   findCapabilityOverride,
   findCutPoint,
+  formatApprovalDeniedReason,
+  formatAsyncSpawnedResult,
+  formatCancelledAgentResult,
+  formatCloseAlreadyResolvedResult,
+  formatCloseMissingAgentResult,
+  formatCoordinatorRoundMessage,
+  formatCoordinatorTaskNotifications,
+  formatCoordinatorWorkerReports,
   formatEnvironment,
   formatInstructions,
-  formatSize,
+  formatInvalidAgentTypeResult,
+  formatMissingAgentsResult,
+  formatSpawnBlockedResult,
+  formatSyncSubAgentErrorResult,
+  formatSyncSubAgentResult,
+  formatWaitErrorResult,
+  formatWaitResult,
+  formatWaitTimeoutResult,
   gatherEnvironment,
   generateEntryId,
-  generateSummary,
   getAvailableFamilies,
+  getConfiguredSubAgents,
   getDataDir,
   getDefaultResolver,
   getDefaultSessionManager,
   getErrorCategory,
   getGitRootHash,
+  getInstalledSubAgentBackend,
   getLeafId,
   getModelId,
   getNetworkStatus,
+  getPluginLoader,
   getProjectId,
   getProjectSessionsDir,
+  getProjectSubAgentRolesDir,
   getProviderCompatibility,
   getProviderId,
   getProviderOptionsKey,
   getReasoningConfig,
   getReasoningConfigSync,
+  getRequiredToolHost,
   getRetryDelay,
   getSessionsDir,
   getTemplate,
   getToolRisk,
-  hasStreamProviderFactory,
+  getUsableTokenLimit,
+  getUserSubAgentRolesDir,
   httpServer,
   inferContextWindow,
   inferProvider,
   inferResourceType,
-  isContextOverflowing,
+  installLocalSubAgents,
+  installSubAgentTools,
+  isApprovalMiddleware,
+  isBlockedModelCall,
+  isDefinedPlugin,
+  isHumanInputController,
+  isMarkdownSubAgentRole,
   isRetryable,
   isRetryableCategory,
   likelySupportsReasoning,
   loadGlobalInstructions,
+  loadPluginModule,
   loadResourceContent,
   loadSkillContent,
   loadSkillMetadata,
   localHost,
-  mergePresets,
-  needsCustomStreamProvider,
+  markQueuedFollowUpApplied,
+  matchApprovalArgValue,
+  matchApprovalNumericArg,
+  matchApprovalPattern,
+  matchApprovalRisks,
+  matchApprovalSessions,
+  matchApprovalStringPrefixes,
+  mergeInspection,
+  mergeProfiles,
+  normalizeApprovalCascadePolicy,
+  normalizeFollowUpMode,
+  normalizeRememberScopes,
   normalizeToolReplayPolicy,
   otelMiddleware,
   parseFrontmatter,
   parseJSONL,
+  parseMarkdownSubAgentRole,
   parseRetryDelay,
+  parseSubAgentRoleFrontmatter,
+  parseSubAgentToolSpec,
   plan,
   planNextAgentWorkflowOperation,
   prepareModelStep,
   processStepStream,
-  processStream,
   promptCacheMiddleware,
-  pruneContext,
-  pruneToolResults,
+  queueWorkflowFollowUps,
   quick,
   recordAgentWorkflowReplayDecision,
+  requiresToolHost,
+  resetFrameworkAliases,
+  resetPluginLoader,
+  resolveAgentDefaults,
+  resolveCapability,
+  resolveFrameworkAliases,
+  resolveQueuedFollowUp,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,
   restoreScope,
   review,
   runChatLoop,
-  runConcurrent,
   runModelStep,
   runToolBatch,
+  sandboxDefaultsProvider,
+  selectRememberScope,
   serializeMessage,
   shouldCaptureBaseline,
+  shouldCascadeApprovalDecision,
   shouldIncludeReasoningSummary,
-  shouldPruneContext,
   shouldRetry,
+  silentLogger,
   sleep,
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages,
@@ -2064,11 +3552,12 @@ export {
   summarizeEnvironment,
   supportsReasoning,
   supportsReasoningSync,
+  teamPermissionPolicy,
   toJSONL,
   toJSONLBatch,
+  toSubAgentRole,
   truncateOutput,
   watch,
-  withFileTracking,
   withRetry,
   withinScope
 };