@cuylabs/agent-core 0.9.0 → 0.10.0

package/dist/index.js

@@ -1,36 +1,93 @@
 import {
-  DEFAULT_MAX_CONCURRENT,
-  DEFAULT_MAX_SPAWN_DEPTH,
-  DEFAULT_SESSION_TITLE_PREFIX,
-  SubAgentTracker,
+  DEFAULT_SUBAGENT_CONCURRENCY,
+  DEFAULT_SUBAGENT_DEPTH,
+  DEFAULT_SUBAGENT_SESSION_PREFIX,
+  LOCAL_SUBAGENT_BACKEND,
+  SUBAGENT_TOOL_IDS,
+  clearInstalledSubAgents,
+  configureSubAgents,
+  createCloseAgentTool,
+  createInvokeAgentTool,
   createSubAgentTools,
-  discoverAgentProfiles,
-  getProjectAgentsDir,
-  getUserAgentsDir,
-  isMarkdownProfile,
-  parseAgentFrontmatter,
-  parseMarkdownAgent,
-  parseToolSpec,
-  toAgentProfile
-} from "./chunk-JLXG2SH7.js";
+  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 {
+  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-OFDKHNCX.js";
+  ToolHostRegistry,
+  defaultToolHostRegistry,
+  localHost
+} from "./chunk-X4VN4GIJ.js";
 import {
-  applyPreset,
-  createPreset,
+  LayeredSettings,
+  NullSettings,
+  PluginEventBus,
+  PluginRegistry,
+  StaticSettings,
+  ValidatedSettings,
+  definePlugin,
+  discoverPlugins,
+  getPluginLoader,
+  isDefinedPlugin,
+  loadPluginModule,
+  resetFrameworkAliases,
+  resetPluginLoader,
+  resolveFrameworkAliases
+} from "./chunk-QAL3OMI3.js";
+import {
+  applyProfile,
+  createProfile,
   filterTools,
-  mergePresets
-} from "./chunk-IYWQOJMQ.js";
+  mergeProfiles
+} from "./chunk-TIHPYVAJ.js";
 import {
-  Presets,
+  Profiles,
   careful,
   code,
   explore,
@@ -38,7 +95,7 @@ import {
   quick,
   review,
   watch
-} from "./chunk-EKR6PKXU.js";
+} from "./chunk-6HZBHFOL.js";
 import {
   DEFAULT_INSTRUCTION_PATTERNS,
   DEFAULT_MAX_DEPTH,
@@ -61,58 +118,12 @@ import {
   loadGlobalInstructions,
   summarizeEnvironment
 } from "./chunk-GFTW23FV.js";
-import {
-  AgentTurnEngine,
-  ContextOverflowError,
-  DoomLoopError,
-  advanceAgentTurnState,
-  applyAgentWorkflowCommitResult,
-  applyAgentWorkflowModelStepResult,
-  applyAgentWorkflowToolBatchResult,
-  applyAgentWorkflowToolCallResult,
-  cloneAgentWorkflowTurnState,
-  commitOutput,
-  commitStep,
-  convertAgentMessagesToModelMessages,
-  createAgentTaskRunner,
-  createAgentTurnEngine,
-  createAgentTurnState,
-  createAgentTurnStepCommitBatch,
-  createAgentWorkflowTurnState,
-  defaultAgentTaskCheckpointStrategy,
-  failAgentTurnState,
-  failAgentWorkflowTurnState,
-  planNextAgentWorkflowOperation,
-  prepareModelStep,
-  processStepStream,
-  processStream,
-  recordAgentWorkflowReplayDecision,
-  restoreAgentWorkflowMessage,
-  restoreAgentWorkflowMessages,
-  runModelStep,
-  runToolBatch,
-  snapshotAgentWorkflowMessage,
-  snapshotAgentWorkflowMessages
-} from "./chunk-J4QDGZIA.js";
-import {
-  LocalSignal
-} from "./chunk-DXFBQMXP.js";
+import "./chunk-VOUEJSW6.js";
 import {
   createSkillResourceTool,
   createSkillTool,
   createSkillTools
-} from "./chunk-RKEW5WXI.js";
-import {
-  MAX_BYTES,
-  MAX_LINES,
-  TRUNCATE_DIR,
-  TRUNCATE_GLOB,
-  Tool,
-  defineTool,
-  formatSize,
-  normalizeToolReplayPolicy,
-  truncateOutput
-} from "./chunk-MHKK374K.js";
+} from "./chunk-TOTDGK3P.js";
 import {
   DEFAULT_EXTERNAL_DIRS,
   DEFAULT_MAX_SCAN_DEPTH,
@@ -128,6 +139,38 @@ import {
   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,
@@ -152,50 +195,78 @@ import {
   serializeMessage,
   toJSONL,
   toJSONLBatch
-} from "./chunk-UHCJEM2E.js";
+} from "./chunk-ICZ66572.js";
+import {
+  createEventBus
+} from "./chunk-2TTOLHBT.js";
 import {
+  AgentTurnEngine,
   ContextManager,
+  ContextOverflowError,
   DEFAULT_CONTEXT_LIMITS,
-  PRUNE_PROTECTED_TOOLS,
+  DoomLoopError,
+  advanceAgentTurnState,
+  applyAgentWorkflowCommitResult,
+  applyAgentWorkflowModelStepResult,
+  applyAgentWorkflowToolBatchResult,
+  applyAgentWorkflowToolCallResult,
+  applyWorkflowInterventions,
+  cloneAgentWorkflowTurnState,
+  commitOutput,
+  commitStep,
+  createAgentTaskRunner,
+  createAgentTurnEngine,
+  createAgentTurnState,
+  createAgentTurnStepCommitBatch,
+  createAgentWorkflowTurnState,
+  defaultAgentTaskCheckpointStrategy,
+  drainWorkflowInterventions,
   estimateConversationTokens,
   estimateMessageTokens,
   estimateTokens,
+  failAgentTurnState,
+  failAgentWorkflowTurnState,
   findCutPoint,
-  generateSummary,
-  isContextOverflowing,
-  pruneContext,
-  pruneToolResults,
-  shouldPruneContext
-} from "./chunk-WWYYNWEW.js";
-import {
-  dockerHost,
-  localHost
-} from "./chunk-VNQBHPCT.js";
+  getUsableTokenLimit,
+  planNextAgentWorkflowOperation,
+  prepareModelStep,
+  processStepStream,
+  queueWorkflowFollowUps,
+  recordAgentWorkflowReplayDecision,
+  restoreAgentWorkflowMessage,
+  restoreAgentWorkflowMessages,
+  runModelStep,
+  runToolBatch,
+  snapshotAgentWorkflowMessage,
+  snapshotAgentWorkflowMessages
+} from "./chunk-WBPOZ7CL.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-WKHDSSXG.js";
-import {
-  executeAgentToolCall
-} from "./chunk-H3FUYU52.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,
@@ -203,35 +274,7 @@ import {
   isRetryable,
   isRetryableCategory,
   parseRetryDelay
-} from "./chunk-4QFNWPIF.js";
-import {
-  createScope,
-  currentScope,
-  restoreScope,
-  snapshotScope,
-  streamWithinScope,
-  withinScope
-} from "./chunk-N7P4PN3O.js";
-import {
-  createMCPManager,
-  defineServer,
-  httpServer,
-  sseServer,
-  stdioServer
-} from "./chunk-ZXAKHMWH.js";
-import {
-  MiddlewareRunner,
-  approvalMiddleware,
-  createTelemetryConfig,
-  otelMiddleware,
-  promptCacheMiddleware
-} from "./chunk-MAZ5DY5B.js";
-import {
-  ApprovalDeniedError,
-  ApprovalTimeoutError,
-  createApprovalHandler,
-  getToolRisk
-} from "./chunk-5ARZJWD2.js";
+} from "./chunk-N3VX7FEE.js";
 import {
   CacheCapabilitySource,
   CapabilityCache,
@@ -262,7 +305,31 @@ import {
   shouldIncludeReasoningSummary,
   supportsReasoning,
   supportsReasoningSync
-} from "./chunk-UDCZ673N.js";
+} from "./chunk-RN6WZEUF.js";
+import "./chunk-SPBFQXOT.js";
+import {
+  createMCPManager,
+  httpServer,
+  sseServer,
+  stdioServer
+} from "./chunk-ROTGCYDW.js";
+import {
+  MiddlewareRunner,
+  approvalMiddleware,
+  createTelemetryConfig,
+  isApprovalMiddleware,
+  otelMiddleware,
+  promptCacheMiddleware
+} from "./chunk-NDZWXCBZ.js";
+import {
+  DEFAULT_AGENT_NAME,
+  DEFAULT_MAX_STEPS,
+  DEFAULT_MAX_TOKENS,
+  DEFAULT_SYSTEM_PROMPT,
+  isBlockedModelCall,
+  resolveAgentDefaults,
+  sandboxDefaultsProvider
+} from "./chunk-CJI7PVS2.js";
 import {
   DEFAULT_RESOLVER_OPTIONS,
   PatternCapabilitySource,
@@ -277,23 +344,419 @@ import {
   likelySupportsReasoning
 } from "./chunk-I6PKJ7XQ.js";
 import {
-  LayeredSettings,
-  NullSettings,
-  PluginEventBus,
-  PluginRegistry,
-  StaticSettings,
-  ValidatedSettings,
-  definePlugin,
-  discoverPlugins,
-  getPluginLoader,
-  isDefinedPlugin,
-  loadPluginModule,
-  resetFrameworkAliases,
-  resetPluginLoader,
-  resolveFrameworkAliases
-} from "./chunk-WGZAPU6N.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/agent/intervention.ts
+// src/intervention/intervention.ts
 var InterventionController = class {
   /** Immediate interventions — applied at the next step boundary */
   immediate = [];
@@ -304,6 +767,8 @@ var InterventionController = class {
    * 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)
   // ---------------------------------------------------------------------------
@@ -367,9 +832,9 @@ var InterventionController = class {
    */
   queueNext(message) {
     const id = crypto.randomUUID();
-    this.deferred.push(
-      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
-    );
+    const queued = Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() });
+    this.deferred.push(queued);
+    this.onDeferredQueued?.(queued);
     return id;
   }
   /**
@@ -389,132 +854,24 @@ var InterventionController = class {
   get hasDeferred() {
     return this.deferred.length > 0;
   }
-  /** Number of deferred messages */
-  get deferredCount() {
-    return this.deferred.length;
-  }
-  // ---------------------------------------------------------------------------
-  // Housekeeping
-  // ---------------------------------------------------------------------------
-  /** Clear all queues (immediate + deferred) */
-  clear() {
-    this.immediate.length = 0;
-    this.deferred.length = 0;
-  }
-  /** Reset the controller for a new turn (clears onApplied, keeps queues) */
-  resetCallbacks() {
-    this.onApplied = void 0;
-  }
-};
-
-// src/agent/chat-loop/commit.ts
-function createChatLoopCommitBatchApplier(params) {
-  const { turnEngine, sessions, middlewareRunner } = params;
-  return async function* applyCommitBatch(batch, options = {}) {
-    turnEngine.recordEvent(batch.startBoundary, (/* @__PURE__ */ new Date()).toISOString());
-    middlewareRunner.emitEvent(batch.startBoundary);
-    yield batch.startBoundary;
-    await sessions.addMessages(batch.messages);
-    turnEngine.recordEvent(batch.finishBoundary, (/* @__PURE__ */ new Date()).toISOString());
-    middlewareRunner.emitEvent(batch.finishBoundary);
-    yield batch.finishBoundary;
-    if (options.emitMessages) {
-      for (const committedMessage of batch.messages) {
-        yield { type: "message", message: committedMessage };
-      }
-    }
-  };
-}
-
-// src/agent/session.ts
-async function ensureSessionLoaded(options) {
-  const { sessionId, sessions, cwd } = options;
-  if (sessions.getSessionId() === sessionId) {
-    return;
-  }
-  const exists = await sessions.sessionExists(sessionId);
-  if (exists) {
-    await sessions.load(sessionId);
-  } else {
-    await sessions.create({ id: sessionId, cwd });
-  }
-}
-async function repairOrphanedToolCalls(sessions) {
-  const messages = sessions.getMessages();
-  const pendingCallIds = /* @__PURE__ */ new Map();
-  for (const message of messages) {
-    if (message.role === "assistant" && message.toolCalls) {
-      for (const toolCall of message.toolCalls) {
-        pendingCallIds.set(toolCall.toolCallId, { toolName: toolCall.toolName });
-      }
-    }
-    if (message.role === "tool" && message.toolCallId) {
-      pendingCallIds.delete(message.toolCallId);
-    }
-  }
-  for (const [toolCallId, { toolName }] of pendingCallIds) {
-    const toolMessage = {
-      id: crypto.randomUUID(),
-      role: "tool",
-      content: "Error: tool execution failed (result was not recorded)",
-      toolCallId,
-      toolName,
-      result: "Error: tool execution failed (result was not recorded)",
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    await sessions.addMessage(toolMessage);
-  }
-}
-async function createSubAgentRunSession(options) {
-  const sessionId = options.parentSessionId ? `${options.parentSessionId}:sub:${crypto.randomUUID().slice(0, 8)}` : `sub:${crypto.randomUUID().slice(0, 8)}`;
-  await options.sessions.create({
-    id: sessionId,
-    cwd: options.cwd,
-    title: options.title ?? "Sub-agent task",
-    parentSessionId: options.parentSessionId
-  });
-  return sessionId;
-}
-function getVisibleSessionMessages(sessions) {
-  const leafId = sessions.getLeafId();
-  if (!leafId) {
-    return [];
+  /** Number of deferred messages */
+  get deferredCount() {
+    return this.deferred.length;
   }
-  const path = buildEntryPath(
-    sessions.getEntries(),
-    leafId
-  );
-  const visible = [];
-  let skipUntilId;
-  for (const entry of path) {
-    if (entry.type === "compaction") {
-      visible.push({
-        message: {
-          id: entry.id,
-          role: "system",
-          content: `## Previous Conversation Summary
-
-${entry.summary}`,
-          createdAt: new Date(entry.timestamp)
-        }
-      });
-      skipUntilId = entry.firstKeptEntryId;
-      continue;
-    }
-    if (skipUntilId && entry.id !== skipUntilId) {
-      continue;
-    }
-    if (entry.id === skipUntilId) {
-      skipUntilId = void 0;
-    }
-    if (entry.type === "message") {
-      visible.push({
-        message: deserializeMessage(entry.message)
-      });
-    }
+  // ---------------------------------------------------------------------------
+  // Housekeeping
+  // ---------------------------------------------------------------------------
+  /** Clear all queues (immediate + deferred) */
+  clear() {
+    this.immediate.length = 0;
+    this.deferred.length = 0;
   }
-  return visible;
-}
+  /** 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) {
@@ -524,9 +881,6 @@ function createAgentToolRecord(tools) {
   }
   return toolRecord;
 }
-function getAgentContextStats(contextManager, messages) {
-  return contextManager.getStats(messages);
-}
 function buildFallbackCompactionSummary(messages) {
   const excerpt = messages.map((message) => {
     const role = message.role.toUpperCase();
@@ -539,9 +893,9 @@ function buildFallbackCompactionSummary(messages) {
   return trimmed.length > 0 ? trimmed : "Earlier conversation context was compacted.";
 }
 async function compactAgentContext(options) {
-  const { contextManager, sessions } = options;
-  const visibleMessages = getVisibleSessionMessages(sessions);
-  const messages = visibleMessages.map((item) => item.message);
+  const { contextManager, sessions, logger } = options;
+  const log = logger ?? silentLogger;
+  const messages = getVisibleSessionMessages(sessions);
   if (!contextManager.shouldPrune(messages)) {
     return {
       removedCount: 0,
@@ -559,7 +913,10 @@ async function compactAgentContext(options) {
     removedCount = result.removedCount;
     summarized = result.summarized;
     summary = result.summary;
-  } catch {
+  } catch (pruneError) {
+    log.warn("Context compaction LLM summarisation failed, using fallback", {
+      error: pruneError instanceof Error ? pruneError.message : String(pruneError)
+    });
   }
   if (removedCount === 0) {
     removedCount = findCutPoint(
@@ -643,29 +1000,56 @@ function createAgentTurnRuntimeConfig(options) {
     ...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) {
+  const { turnEngine, sessions, middlewareRunner } = params;
+  return async function* applyCommitBatch(batch, options = {}) {
+    turnEngine.recordEvent(batch.startBoundary, (/* @__PURE__ */ new Date()).toISOString());
+    middlewareRunner.emitEvent(batch.startBoundary);
+    yield batch.startBoundary;
+    await sessions.addMessages(batch.messages);
+    turnEngine.recordEvent(batch.finishBoundary, (/* @__PURE__ */ new Date()).toISOString());
+    middlewareRunner.emitEvent(batch.finishBoundary);
+    yield batch.finishBoundary;
+    if (options.emitMessages) {
+      for (const committedMessage of batch.messages) {
+        yield { type: "message", message: committedMessage };
+      }
+    }
+  };
+}
+
 // src/agent/chat-loop/compaction.ts
 async function runAutoCompaction(params) {
-  const { contextManager, sessions } = params;
+  const { contextManager, sessions, logger } = params;
   const messages = sessions.getMessages();
   if (!contextManager.shouldPrune(messages)) {
     return [];
   }
   const events = [{ type: "status", status: "processing" }];
-  const pruneResult = await compactAgentContext({
-    contextManager,
-    sessions
-  });
-  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;
@@ -683,23 +1067,6 @@ async function buildChatSystemPrompts(params) {
   });
 }
 
-// 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)
-  };
-}
-
 // src/agent/chat-loop/loop.ts
 async function* runChatLoop(deps) {
   yield* streamWithinScope(
@@ -711,11 +1078,12 @@ async function* runChatLoop(deps) {
     (async function* () {
       const {
         sessionId,
+        turnId,
         message,
         abort,
         systemOverride,
         sessions,
-        tools: toolRecord,
+        tools: liveTools,
         config,
         turnTracker,
         interventionCtrl,
@@ -725,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(),
@@ -753,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,
@@ -778,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,
@@ -794,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,
@@ -814,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;
           }
@@ -829,7 +1232,8 @@ async function* runChatLoop(deps) {
         if (config.compaction?.auto !== false) {
           const compactionEvents = await runAutoCompaction({
             contextManager,
-            sessions
+            sessions,
+            logger: deps.logger
           });
           for (const event of compactionEvents) {
             yield event;
@@ -874,6 +1278,9 @@ async function* runChatLoop(deps) {
             usage: chatUsage,
             error: chatError,
             output: chatOutput
+          }, {
+            sessionId,
+            turnId
           });
         }
       }
@@ -883,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,
@@ -925,6 +1332,8 @@ function createForkedAgentConfig(options) {
     parentTools,
     reasoningLevel,
     host,
+    sandbox,
+    humanInputController,
     ownsHost,
     sessions,
     mcpManager,
@@ -941,7 +1350,8 @@ function createForkedAgentConfig(options) {
   return {
     model: forkOptions.model ?? parentConfig.model,
     cwd: parentConfig.cwd,
-    ...ownsHost ? {} : { host },
+    ...ownsHost ? {} : sandbox !== void 0 ? { sandbox } : { host },
+    ...humanInputController ? { humanInput: humanInputController } : {},
     maxOutputTokens: parentConfig.maxOutputTokens,
     maxSteps: forkOptions.maxSteps ?? parentConfig.maxSteps,
     temperature: forkOptions.temperature ?? parentConfig.temperature,
@@ -961,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 };
   }
@@ -971,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 {
@@ -999,6 +1410,393 @@ async function closeMcpManager(manager) {
   };
 }
 
+// src/signal/local.ts
+var LocalSignal = class {
+  /** type → Set<handler> for typed subscriptions */
+  typed = /* @__PURE__ */ new Map();
+  /** handlers that receive every event */
+  wildcard = /* @__PURE__ */ new Set();
+  on(type, handler) {
+    let set = this.typed.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.typed.set(type, set);
+    }
+    const wrapped = (event) => {
+      handler(event);
+    };
+    set.add(wrapped);
+    return () => {
+      set.delete(wrapped);
+      if (set.size === 0) this.typed.delete(type);
+    };
+  }
+  onAny(handler) {
+    this.wildcard.add(handler);
+    return () => {
+      this.wildcard.delete(handler);
+    };
+  }
+  emit(event) {
+    const set = this.typed.get(event.type);
+    if (set) {
+      for (const fn of set) {
+        try {
+          fn(event);
+        } catch {
+        }
+      }
+    }
+    for (const fn of this.wildcard) {
+      try {
+        fn(event);
+      } catch {
+      }
+    }
+  }
+  clear() {
+    this.typed.clear();
+    this.wildcard.clear();
+  }
+};
+
+// src/human/controller.ts
+var HumanInputTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Human input request timed out after ${timeoutMs}ms`);
+    this.name = "HumanInputTimeoutError";
+  }
+};
+var HumanInputUnavailableError = class extends Error {
+  constructor() {
+    super("No human input controller configured");
+    this.name = "HumanInputUnavailableError";
+  }
+};
+function cloneRecord(record) {
+  return structuredClone(record);
+}
+function normalizeStatuses(status) {
+  if (!status) {
+    return void 0;
+  }
+  return new Set(Array.isArray(status) ? status : [status]);
+}
+function inferKind(input) {
+  if (input.kind) {
+    return input.kind;
+  }
+  if (input.options && input.options.length > 0) {
+    return "choice";
+  }
+  return "text";
+}
+function isHumanInputController(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.request === "function" && typeof candidate.respondToRequest === "function" && typeof candidate.getRequest === "function" && typeof candidate.listRequests === "function" && typeof candidate.cancelAll === "function";
+}
+async function emitHumanInputEvent(context, event) {
+  await context?.emitEvent?.(event);
+}
+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;
+  }
+  async function respondToRequest(requestId, response, context = {}) {
+    const current = pending.get(requestId);
+    if (!current) {
+      throw new Error(`Human input request not found: ${requestId}`);
+    }
+    await current.ready;
+    pending.delete(requestId);
+    clearTimeout(current.timeoutId);
+    const respondedAt = Date.now();
+    const next = {
+      ...current.record,
+      status: "answered",
+      updatedAt: respondedAt,
+      respondedAt,
+      response: structuredClone(response)
+    };
+    current.resolve(response);
+    const emitEvent = context.emitEvent ?? current.emitEvent;
+    await emitHumanInputEvent(
+      { emitEvent },
+      {
+        type: "human-input-resolved",
+        id: requestId,
+        response
+      }
+    );
+    await emitHumanInputEvent(
+      { emitEvent },
+      { type: "status", status: "processing" }
+    );
+    return cloneRecord(next);
+  }
+  function getRequest(requestId) {
+    const current = pending.get(requestId);
+    return current ? cloneRecord(current.record) : void 0;
+  }
+  function listRequests(options = {}) {
+    const statuses = normalizeStatuses(options.status);
+    return [...pending.values()].map((entry) => cloneRecord(entry.record)).filter((record) => {
+      if (options.sessionId && record.sessionId !== options.sessionId) {
+        return false;
+      }
+      if (statuses && !statuses.has(record.status)) {
+        return false;
+      }
+      return true;
+    }).sort((left, right) => left.createdAt - right.createdAt);
+  }
+  function cancelAll(reason = "Cancelled") {
+    for (const [requestId, current] of pending) {
+      pending.delete(requestId);
+      clearTimeout(current.timeoutId);
+      current.record = {
+        ...current.record,
+        status: "cancelled",
+        updatedAt: Date.now()
+      };
+      current.reject(new Error(reason));
+      void emitHumanInputEvent(
+        { emitEvent: current.emitEvent },
+        { type: "status", status: "processing" }
+      );
+    }
+  }
+  return {
+    get hasPendingRequests() {
+      return pending.size > 0;
+    },
+    request,
+    respondToRequest,
+    getRequest,
+    listRequests,
+    cancelAll
+  };
+}
+
+// src/human/handler.ts
+function createHumanInputHandler(config = {}) {
+  return createHumanInputController(config);
+}
+
+// src/human/tool.ts
+import { z } from "zod";
+function createHumanInputTool(options = {}) {
+  if (options.controller) {
+    return createHumanInputToolWithController(options.controller, options);
+  }
+  if (options.onRequest || options.timeout !== void 0) {
+    return createHumanInputToolWithController(
+      createHumanInputController(options),
+      options
+    );
+  }
+  return createHumanInputToolWithController(void 0, options);
+}
+function createHumanInputToolWithController(controller, options = {}) {
+  return Tool.define(
+    options.name ?? "question",
+    {
+      description: options.description ?? "Ask a human for missing input, a decision, a confirmation, or a choice.",
+      parameters: z.object({
+        title: z.string().min(1).describe("Short heading for the request"),
+        question: z.string().min(1).describe("What to ask the human"),
+        kind: z.enum(["text", "confirm", "choice"]).optional(),
+        options: z.array(
+          z.object({
+            label: z.string().min(1),
+            value: z.string().optional(),
+            description: z.string().optional()
+          })
+        ).optional(),
+        allowMultiple: z.boolean().optional(),
+        placeholder: z.string().optional(),
+        confirmLabel: z.string().optional(),
+        denyLabel: z.string().optional()
+      }),
+      validate: (params) => {
+        const kind = params.kind ?? (params.options?.length ? "choice" : "text");
+        if (kind === "choice" && (!params.options || params.options.length === 0)) {
+          return {
+            ok: false,
+            reason: "Choice requests must include at least one option."
+          };
+        }
+        if (kind !== "choice" && params.allowMultiple) {
+          return {
+            ok: false,
+            reason: "allowMultiple is only valid for choice requests."
+          };
+        }
+        return { ok: true };
+      },
+      capabilities: {
+        readOnly: true,
+        riskLevel: "safe",
+        parallelSafe: false,
+        humanInput: true
+      },
+      replayPolicy: {
+        mode: "manual",
+        sideEffectLevel: "external",
+        reason: "Depends on a human response before execution can continue."
+      },
+      execute: async (params, ctx) => {
+        let response;
+        try {
+          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 = [
   "computer-use-preview",
@@ -1035,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) {
@@ -1063,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
   };
 }
@@ -1089,9 +1885,6 @@ function resolveInitialReasoningLevel(config) {
 function createAgentState(config) {
   return {
     model: config.model,
-    systemPrompt: config.systemPrompt,
-    cwd: config.cwd,
-    isStreaming: false,
     reasoningLevel: resolveInitialReasoningLevel(config)
   };
 }
@@ -1115,7 +1908,7 @@ function resolveAgentContextLimits(contextWindow, compactionConfig = {}) {
     Math.max(1024, Math.round(contextWindow * 0.25)),
     Math.max(512, proportionalReserve)
   );
-  const usableWindow = Math.max(512, contextWindow - reserveTokens);
+  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 {
@@ -1131,51 +1924,95 @@ function resolveAgentContextLimits(contextWindow, compactionConfig = {}) {
   };
 }
 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),
-    ownsHost: input.host === void 0,
+    ...humanInputSetup,
+    ...executionEnvironment,
     middlewareRunner: middlewareSetup.middlewareRunner,
+    logger,
     ...middlewareSetup.telemetrySettings ? { telemetrySettings: middlewareSetup.telemetrySettings } : {},
     ...middlewareSetup.tracingShutdown ? { tracingShutdown: middlewareSetup.tracingShutdown } : {}
   };
@@ -1212,6 +2049,10 @@ 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 */
@@ -1228,6 +2069,8 @@ var Agent = class _Agent {
   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;
@@ -1240,8 +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();
@@ -1256,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() {
@@ -1328,8 +2178,8 @@ var Agent = class _Agent {
   async acquireSessionLock(sessionId) {
     const previous = this.sessionLocks.get(sessionId) ?? Promise.resolve();
     let releaseLock;
-    const current = new Promise((resolve) => {
-      releaseLock = resolve;
+    const current = new Promise((resolve2) => {
+      releaseLock = resolve2;
     });
     const chain = previous.catch(() => void 0).then(() => current);
     this.sessionLocks.set(sessionId, chain);
@@ -1344,6 +2194,29 @@ var Agent = class _Agent {
       }
     };
   }
+  /**
+   * 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) {
@@ -1377,7 +2250,6 @@ var Agent = class _Agent {
       0,
       this.activeTurnCount + (active ? 1 : -1)
     );
-    this.state.isStreaming = this.activeTurnCount > 0;
   }
   async syncSessionView(sessionId) {
     if (!await this.sessions.sessionExists(sessionId)) {
@@ -1394,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(sessions) {
-    await repairOrphanedToolCalls(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.
    *
@@ -1455,15 +2304,16 @@ var Agent = class _Agent {
         cwd: this.config.cwd
       });
       turnTracker.startTurn(turnId);
-      await this.repairOrphanedToolCalls(sessions);
+      await repairOrphanedToolCalls(sessions);
       const mcpTools = await this.ensureMCPConnected();
       const loop = runChatLoop({
         sessionId,
+        turnId,
         message,
         abort,
         systemOverride: options?.system,
         sessions,
-        tools: createAgentToolRecord(this.tools),
+        tools: this.tools,
         config: this.config,
         turnTracker,
         interventionCtrl,
@@ -1473,14 +2323,17 @@ var Agent = class _Agent {
         reasoningLevel: this.state.reasoningLevel,
         promptBuilder: this.promptBuilder,
         host: this.host,
+        humanInputController: this.humanInputController,
         mcpTools,
         telemetrySettings: this.telemetrySettings,
-        toModelMessages: this.toModelMessages.bind(this),
+        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);
@@ -1572,7 +2425,15 @@ 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();
   }
@@ -1613,8 +2474,7 @@ var Agent = class _Agent {
    * ```
    */
   getContextStats() {
-    return getAgentContextStats(
-      this.contextManager,
+    return this.contextManager.getStats(
       this.sessions.getMessages()
     );
   }
@@ -1629,7 +2489,8 @@ var Agent = class _Agent {
   async compactContext() {
     return await compactAgentContext({
       contextManager: this.contextManager,
-      sessions: this.sessions
+      sessions: this.sessions,
+      logger: this._logger
     });
   }
   /**
@@ -1813,14 +2674,12 @@ 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);
@@ -1902,7 +2761,8 @@ var Agent = class _Agent {
   getTurnRuntimeConfig() {
     return createAgentTurnRuntimeConfig({
       config: this.config,
-      telemetrySettings: this.telemetrySettings
+      telemetrySettings: this.telemetrySettings,
+      reserveTokens: this.contextManager.getLimits().reserveTokens
     });
   }
   /**
@@ -1911,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.
    *
@@ -1920,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)
   // ============================================================================
@@ -1961,6 +2853,8 @@ 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,
@@ -1970,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.
@@ -2068,6 +2962,7 @@ var Agent = class _Agent {
    */
   async close() {
     this._signal.clear();
+    this.humanInputController?.cancelAll("Agent closed");
     if (this.tracingShutdown) {
       await this.tracingShutdown();
     }
@@ -2077,30 +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) {
-      if (options?.abort?.aborted) break;
-      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,
@@ -2111,39 +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,
   NullSettings,
-  OUTPUT_TOKEN_MAX,
   PRIORITY_BASE,
   PRIORITY_CUSTOM,
   PRIORITY_ENVIRONMENT,
@@ -2154,39 +3272,52 @@ export {
   PatternCapabilitySource,
   PluginEventBus,
   PluginRegistry,
-  Presets,
+  Profiles,
   PromptBuilder,
   RemoteCapabilityFetcher,
   RemoteCapabilitySource,
   SKILL_FILENAME,
   STANDARD_LEVELS,
   STORAGE_VERSION,
+  SUBAGENT_TOOL_IDS,
   SessionManager,
   SkillRegistry,
   SourcePriority,
   StaticSettings,
-  SubAgentTracker,
-  TRUNCATE_DIR,
-  TRUNCATE_GLOB,
+  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,
@@ -2194,58 +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,
+  defaultToolHostRegistry,
   definePlugin,
-  defineServer,
-  defineTool,
+  describeApprovalOperation,
   deserializeMessage,
   detectModelFamily,
-  discoverAgentProfiles,
   discoverInstructions,
   discoverPlugins,
   discoverSkills,
-  dockerHost,
+  discoverSubAgentRoles,
+  drainWorkflowInterventions,
   emptySkillRegistry,
+  ensureNonEmpty,
+  ensureSessionLoaded,
   estimateConversationTokens,
   estimateMessageTokens,
   estimateTokens,
+  evaluateCoordinatorRoundTransition,
   executeAgentToolCall,
   explore,
+  extractApprovalPatterns,
   extractFilePathsFromArgs,
   extractModelId,
   extractProvider,
@@ -2255,43 +3423,64 @@ 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,
-  getProjectAgentsDir,
   getProjectId,
   getProjectSessionsDir,
+  getProjectSubAgentRolesDir,
   getProviderCompatibility,
   getProviderId,
   getProviderOptionsKey,
   getReasoningConfig,
   getReasoningConfigSync,
+  getRequiredToolHost,
   getRetryDelay,
   getSessionsDir,
   getTemplate,
   getToolRisk,
-  getUserAgentsDir,
-  hasStreamProviderFactory,
+  getUsableTokenLimit,
+  getUserSubAgentRolesDir,
   httpServer,
   inferContextWindow,
   inferProvider,
   inferResourceType,
-  isContextOverflowing,
+  installLocalSubAgents,
+  installSubAgentTools,
+  isApprovalMiddleware,
+  isBlockedModelCall,
   isDefinedPlugin,
-  isMarkdownProfile,
+  isHumanInputController,
+  isMarkdownSubAgentRole,
   isRetryable,
   isRetryableCategory,
   likelySupportsReasoning,
@@ -2301,42 +3490,56 @@ export {
   loadSkillContent,
   loadSkillMetadata,
   localHost,
-  mergePresets,
-  needsCustomStreamProvider,
+  markQueuedFollowUpApplied,
+  matchApprovalArgValue,
+  matchApprovalNumericArg,
+  matchApprovalPattern,
+  matchApprovalRisks,
+  matchApprovalSessions,
+  matchApprovalStringPrefixes,
+  mergeInspection,
+  mergeProfiles,
+  normalizeApprovalCascadePolicy,
+  normalizeFollowUpMode,
+  normalizeRememberScopes,
   normalizeToolReplayPolicy,
   otelMiddleware,
-  parseAgentFrontmatter,
   parseFrontmatter,
   parseJSONL,
-  parseMarkdownAgent,
+  parseMarkdownSubAgentRole,
   parseRetryDelay,
-  parseToolSpec,
+  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,
@@ -2349,12 +3552,12 @@ export {
   summarizeEnvironment,
   supportsReasoning,
   supportsReasoningSync,
-  toAgentProfile,
+  teamPermissionPolicy,
   toJSONL,
   toJSONLBatch,
+  toSubAgentRole,
   truncateOutput,
   watch,
-  withFileTracking,
   withRetry,
   withinScope
 };