@theokit/sdk 5.13.0 → 5.15.0

package/dist/{chunk-JX4LB6XO.js → chunk-5M5GQYBM.js}

@@ -1,46 +1,47 @@
 import { submit, emitRunEvent } from './chunk-HWMGR3HA.js';
-import { enqueueSessionWrite, hydrateSession, persistTurnToTranscript, flushSessionWrites, appendSessionMessage, getSessionMessages, discardSession, clearSession } from './chunk-XOYNB3YN.js';
-import { IndexManager } from './chunk-2C24NSNV.js';
+import { enqueueSessionWrite, hydrateSession, persistTurnToTranscript, flushSessionWrites, appendSessionMessage, getSessionMessages, discardSession, clearSession } from './chunk-23SS4ID4.js';
+import { IndexManager } from './chunk-3BBTHFGJ.js';
 import { currentPersonalityContext, warnPersonalitySwitchInsideFork } from './chunk-HJ2LV464.js';
 import { extractCodePlugins, isCodePlugin } from './chunk-2SFBB54R.js';
-import { createOpenAiCompatibleRuntime } from './chunk-H7G65PNI.js';
+import { createOpenAiCompatibleRuntime } from './chunk-VCQ37TC5.js';
 import { persistActiveMemoryTranscript } from './chunk-QK2ERTO3.js';
-import { resolveMaxFacts, writeSessionSummary, resolveMemoryRoot, MEMORY_KINDS, appendFact, readFacts, legacyMemoryJsonPath, memoryMdPath, appendFactToMarkdown } from './chunk-DF77RBF4.js';
-import { FsSessionStore } from './chunk-AB4OPJLD.js';
-import { discoverProviderPlugins, validateApiKeyShape, getConfiguredBaseUrl, httpRequest, isFixtureApiKey, presentProviderCredentialEnvVars, readTrustArray, buildDefaultSummarizer, shouldUseRealLocalRuntime, parseSseStream, CircuitBreaker, trustFilePath, resolveRunProvider, mergeExplicitApiKey, resolveProviderChain, abortError, tryFirstEvent, relayStream, renderToolResultContentText } from './chunk-2PRGRYEQ.js';
+import { resolveMaxFacts, writeSessionSummary, resolveMemoryRoot, MEMORY_KINDS, appendFact, readFacts, legacyMemoryJsonPath, memoryMdPath, appendFactToMarkdown } from './chunk-LCCT5ZXJ.js';
+import { FsSessionStore } from './chunk-RGVMJU57.js';
+import { discoverProviderPlugins, validateApiKeyShape, getConfiguredBaseUrl, httpRequest, isFixtureApiKey, presentProviderCredentialEnvVars, readTrustArray, buildDefaultSummarizer, shouldUseRealLocalRuntime, parseSseStream, CircuitBreaker, trustFilePath, resolveRunProvider, mergeExplicitApiKey, resolveProviderChain, abortError, tryFirstEvent, relayStream, renderToolResultContentText } from './chunk-IOBHFP2E.js';
 import { resolveChildEnv } from './chunk-HKCKOAIO.js';
 import { DEFAULT_MAX_BYTES_PER_FILE, runDiscovery, truncateWithMarker } from './chunk-KCM3RMKR.js';
 import { warnFailureOnce, loadHookConfig, warnOnce } from './chunk-XJ3WU5CZ.js';
+import { getTokens, lockedRefresh, refreshAccessToken, runPkceFlow, setTokens } from './chunk-X7CE7Y5W.js';
 import { readVersionedJson, writeVersionedJson } from './chunk-OLJOI4LK.js';
 import { toJsonSchema } from './chunk-7I5Z3UBJ.js';
 import { sanitizeToolInput } from './chunk-FJWQP6EE.js';
 import { withInheritedSubAgentCredentials, subAgentToolsFromDefinitions } from './chunk-VZGE7NAI.js';
 import { setAgentFacade } from './chunk-6X6ID4MO.js';
-import { escapeBlockBody, buildSkillsBlock, discoverSkills, stripSkillFrontmatter } from './chunk-NHOEXFZT.js';
+import { escapeBlockBody, buildSkillsBlock, discoverSkills, stripSkillFrontmatter } from './chunk-2HXTNVLM.js';
 import { withToolWhitelist, checkToolWhitelist } from './chunk-SAGRF4IB.js';
 import { validateArtifactPath, PathTraversalError, safePathJoin } from './chunk-PKRPV3R7.js';
 import { insideRoot, atOrInsideRoot } from './chunk-UKMBRMGT.js';
 import { mapWithConcurrency } from './chunk-ORLTGPOS.js';
 import { expandTilde, defaultBaseDir } from './chunk-XESYJ4JC.js';
-import { withFileLock } from './chunk-354F3OF5.js';
-import { withCwdMutex } from './chunk-Q5EWJPRY.js';
+import { withFileLock } from './chunk-FGGVSHDW.js';
+import { withCwdMutex } from './chunk-PPU2D4FZ.js';
 import { sweepStaleAtomicTemps, atomicWriteJson } from './chunk-M4U24U6G.js';
-import { loadSubagents, pluginBundleDirs } from './chunk-RN3XDZGS.js';
+import { loadSubagents, pluginBundleDirs } from './chunk-WM646HEN.js';
 import { reportUndeclaredSources, theokitConfigRoot, undefinedVariablesIn, getTheokitHome, adapterForConfigPath, adaptersForSurface, projectConfigRoots, pluginBundleRoots } from './chunk-YMVTUV5K.js';
 import { readWorkspaceDir, parseSimpleYaml } from './chunk-Q7UG242V.js';
 import { resolveEffectiveContextWindow, CONTEXT_WINDOW_FLOOR, CONTEXT_WINDOW_MARGIN } from './chunk-SZQFCHU6.js';
-import { isAnthropicFamilyModel } from './chunk-2SFLLOMN.js';
+import { isAnthropicFamilyModel } from './chunk-CBBT42VX.js';
 import { parseModelId } from './chunk-R7WIIPUR.js';
-import { getProviderProfile } from './chunk-NKQVLWDF.js';
-import { getCatalogModelInfo, isPatchedModelKey } from './chunk-5HSMH2ZZ.js';
+import { getProviderProfile } from './chunk-YKNBTHMD.js';
+import { getCatalogModelInfo, isPatchedModelKey } from './chunk-RZL2W4C3.js';
 import { globalSingleton } from './chunk-AGACYRJ2.js';
 import { boundFetch } from './chunk-Q7GYMXVC.js';
-import { AgentRunError, coerceToKnownAgentRunErrorCode, UnknownAgentError, ConfigurationError, AuthenticationError, AgentDisposedError, UnsupportedRunOperationError, NetworkError, TheokitAgentError } from './chunk-TNFOU6SB.js';
-import { diag, resolveApiKey, API_KEY_ENV_VAR, redactSecrets, diagFailure } from './chunk-3OY6H3I7.js';
+import { AgentRunError, coerceToKnownAgentRunErrorCode, UnknownAgentError, ConfigurationError, AuthenticationError, AgentDisposedError, UnsupportedRunOperationError, TheokitAgentError, NetworkError } from './chunk-TNFOU6SB.js';
+import { diag, resolveApiKey, diagFailure, API_KEY_ENV_VAR, redactSecrets } from './chunk-3OY6H3I7.js';
 import { stat, mkdir, readFile, readdir, access, unlink } from 'fs/promises';
 import { randomUUID, createHash } from 'crypto';
-import { join, dirname, isAbsolute, resolve, relative } from 'path';
-import { existsSync, readFileSync, realpathSync } from 'fs';
+import { join, dirname, isAbsolute, delimiter, resolve, relative } from 'path';
+import { existsSync, readFileSync, realpathSync, accessSync, constants } from 'fs';
 import { platform } from 'process';
 import { spawn } from 'child_process';
 import { pathToFileURL } from 'url';
@@ -1673,7 +1674,10 @@ var RealCloudRun = class extends FixtureRunBase {
       await this.consumeStream(response);
     } catch (cause) {
       if (this.terminated) return;
-      this.fail(cause instanceof Error ? cause.message : String(cause));
+      this.fail(
+        cause instanceof Error ? cause.message : String(cause),
+        cause instanceof TheokitAgentError ? cause : void 0
+      );
     }
   }
   async postRun(apiKey, baseUrl) {
@@ -1751,13 +1755,17 @@ var RealCloudRun = class extends FixtureRunBase {
       message: { role: "assistant", content: [{ type: "text", text }] }
     };
   }
-  fail(message, code) {
+  fail(message, cause) {
     const event = this.buildAssistantEvent(message);
     this.script.events.push(event);
     this.notifyNewEvents();
     this.script.result = message;
     if (this.script.errorDetail === void 0) {
-      this.script.errorDetail = { message, ...code !== void 0 ? { code } : {} };
+      this.script.errorDetail = {
+        message,
+        ...cause?.code !== void 0 ? { code: cause.code } : {},
+        ...cause !== void 0 ? { cause } : {}
+      };
     }
     this.transitionTo("error");
   }
@@ -3163,34 +3171,230 @@ async function importEntry(candidate) {
 function isGeneralPlugin(value) {
   return isCodePlugin(value) && value.kind === "general" && typeof value.name === "string";
 }
+
+// src/internal/runtime/registry/live-agent-registry.ts
+var DEFAULT_MAX_AGENTS = 100;
+var DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_SWEEP_INTERVAL_MS = 6e4;
+var LiveAgentRegistry = class {
+  #agents = /* @__PURE__ */ new Map();
+  #maxAgents = DEFAULT_MAX_AGENTS;
+  #idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS;
+  #sweepIntervalMs = DEFAULT_SWEEP_INTERVAL_MS;
+  #onEvict;
+  #sweepTimer;
+  /**
+   * Reconfigure registry behavior. Process-wide singleton (D310) — last
+   * configure call wins for all subsequent operations.
+   */
+  configure(opts) {
+    if (opts.maxAgents !== void 0) this.#maxAgents = Math.max(0, opts.maxAgents);
+    if (opts.idleTimeoutMs !== void 0) this.#idleTimeoutMs = Math.max(0, opts.idleTimeoutMs);
+    if (opts.sweepIntervalMs !== void 0)
+      this.#sweepIntervalMs = Math.max(1e3, opts.sweepIntervalMs);
+    this.#onEvict = opts.onEvict;
+    this.#stopSweep();
+    if (this.#idleTimeoutMs > 0) this.#startSweep();
+  }
+  /**
+   * Lookup a cached agent. `get` is a use — refreshes `lastUsedAt` so the
+   * entry survives LRU eviction.
+   */
+  get(id) {
+    const entry = this.#agents.get(id);
+    if (entry === void 0) return void 0;
+    entry.lastUsedAt = Date.now();
+    return entry.agent;
+  }
+  /**
+   * Insert or overwrite an agent in the cache. Triggers fire-and-forget LRU
+   * eviction when `size > maxAgents`.
+   *
+   * EC-4: when `id` already maps to a DIFFERENT agent instance, dispose the
+   * old one before overwriting (race protection against two `getOrCreate`
+   * calls creating two agents but only the second being cached — the first
+   * would leak file handles + lifecycle controllers).
+   */
+  set(id, agent) {
+    if (this.#maxAgents === 0) return;
+    const existing = this.#agents.get(id);
+    if (existing !== void 0 && existing.agent !== agent) {
+      void existing.agent.dispose().catch(() => {
+        diag(`[theokit-sdk] dispose during overwrite failed (${id})
+`);
+      });
+    }
+    this.#agents.set(id, { agent, lastUsedAt: Date.now() });
+    if (this.#agents.size > this.#maxAgents) void this.#evictLRU();
+  }
+  /**
+   * Remove the entry from the cache WITHOUT calling `dispose()` or
+   * `onEvict`. Used by `LocalAgent.dispose()` itself so the disposed
+   * instance can never be returned by a subsequent `get(id)` (dispose-cache
+   * race fix). Idempotent — calling on an unknown id is a no-op.
+   *
+   * @internal
+   */
+  forget(id) {
+    this.#agents.delete(id);
+  }
+  /**
+   * Explicitly evict an agent by id. Returns `true` when the entry was
+   * present (false = already gone). Calls `agent.dispose()` + `onEvict`
+   * with reason `"explicit"`.
+   */
+  async evict(id) {
+    const entry = this.#agents.get(id);
+    if (entry === void 0) return false;
+    this.#agents.delete(id);
+    await this.#disposeAndNotify(id, entry.agent, "explicit");
+    return true;
+  }
+  /**
+   * Evict every cached agent. Used by graceful shutdown (`process.on('SIGTERM')`)
+   * or end-of-test cleanup.
+   */
+  async evictAll() {
+    const entries = Array.from(this.#agents.entries());
+    this.#agents.clear();
+    this.#stopSweep();
+    for (const [id, entry] of entries) {
+      await this.#disposeAndNotify(id, entry.agent, "explicit");
+    }
+  }
+  /** Number of currently cached agents. */
+  size() {
+    return this.#agents.size;
+  }
+  /** Ids of cached agents, newest first (by lastUsedAt). */
+  ids() {
+    return Array.from(this.#agents.entries()).sort((a, b) => b[1].lastUsedAt - a[1].lastUsedAt).map(([id]) => id);
+  }
+  /**
+   * LRU eviction: drop the entry with the smallest `lastUsedAt`. Runs only
+   * when `size > maxAgents`. Asynchronous because `dispose()` is a Promise;
+   * the hot-path caller (`set`) does not await.
+   *
+   * @internal
+   */
+  async #evictLRU() {
+    if (this.#agents.size <= this.#maxAgents) return;
+    let oldestId;
+    let oldestAt = Infinity;
+    for (const [id, entry2] of this.#agents) {
+      if (entry2.lastUsedAt < oldestAt) {
+        oldestAt = entry2.lastUsedAt;
+        oldestId = id;
+      }
+    }
+    if (oldestId === void 0) return;
+    const entry = this.#agents.get(oldestId);
+    if (entry === void 0) return;
+    this.#agents.delete(oldestId);
+    await this.#disposeAndNotify(oldestId, entry.agent, "lru");
+  }
+  /** Background sweep — drops entries whose `lastUsedAt < now - idleTimeoutMs`. */
+  async #sweepIdle() {
+    if (this.#idleTimeoutMs === 0) return;
+    const threshold = Date.now() - this.#idleTimeoutMs;
+    const toEvict = [];
+    for (const [id, entry] of this.#agents) {
+      if (entry.lastUsedAt < threshold) toEvict.push([id, entry]);
+    }
+    for (const [id, entry] of toEvict) {
+      const current = this.#agents.get(id);
+      if (current === void 0 || current.agent !== entry.agent) continue;
+      this.#agents.delete(id);
+      await this.#disposeAndNotify(id, entry.agent, "idle");
+    }
+  }
+  #startSweep() {
+    this.#sweepTimer = setInterval(() => void this.#sweepIdle(), this.#sweepIntervalMs);
+    this.#sweepTimer.unref?.();
+  }
+  #stopSweep() {
+    if (this.#sweepTimer !== void 0) {
+      clearInterval(this.#sweepTimer);
+      this.#sweepTimer = void 0;
+    }
+  }
+  /** Dispose + notify with errors swallowed (D309). Single chokepoint. */
+  async #disposeAndNotify(id, agent, reason) {
+    try {
+      await agent.dispose();
+    } catch (cause) {
+      const msg = cause instanceof Error ? cause.message : String(cause);
+      diag(`[theokit-sdk] dispose during eviction failed (${id}): ${msg}
+`);
+    }
+    if (this.#onEvict !== void 0) {
+      try {
+        this.#onEvict(id, reason);
+      } catch (cause) {
+        const msg = cause instanceof Error ? cause.message : String(cause);
+        diag(`[theokit-sdk] onEvict listener threw (${id}): ${msg}
+`);
+      }
+    }
+  }
+};
+var liveAgentRegistry = globalSingleton(
+  "theokit-sdk.runtime.live-agents",
+  () => new LiveAgentRegistry()
+);
+function executableExtensions() {
+  return process.platform === "win32" ? ["", ...(process.env.PATHEXT ?? ".EXE;.CMD").split(";")] : [""];
+}
+function isExecutable(file) {
+  try {
+    accessSync(file, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function binaryOnPath(bin) {
+  if (bin.length === 0 || /[\\/]/.test(bin)) return false;
+  const dirs = (process.env.PATH ?? "").split(delimiter).filter((dir) => dir.length > 0);
+  return dirs.some(
+    (dir) => executableExtensions().some((ext) => isExecutable(join(dir, bin + ext)))
+  );
+}
 var SkillsManager = class {
-  constructor(cwd, _enabled, settingSourcesIncludeProject, skillsDir, inline, compatSources = []) {
+  constructor(cwd, enabled, settingSourcesIncludeProject, skillsDir, inline, compatSources = [], bundledDirs = []) {
     this.cwd = cwd;
+    this.enabled = enabled;
     this.settingSourcesIncludeProject = settingSourcesIncludeProject;
     this.skillsDir = skillsDir;
     this.inline = inline;
     this.compatSources = compatSources;
+    this.bundledDirs = bundledDirs;
   }
   cwd;
+  enabled;
   settingSourcesIncludeProject;
   skillsDir;
   inline;
   compatSources;
+  bundledDirs;
   skills = [];
   async initialize() {
     if (!this.settingSourcesIncludeProject) {
-      this.skills = this.mergeInline([]);
+      this.skills = this.mergeInline(await this.discoverFrom(this.bundledDirs));
       return;
     }
     await this.refresh();
   }
   async refresh() {
-    const roots = this.skillsDir === void 0 ? [
+    const ownRoots = this.skillsDir === void 0 ? [
       ...projectConfigRoots(this.cwd, this.compatSources, "skills").map(
         (root) => join(root, "skills")
       ),
       ...(await pluginBundleDirs(this.cwd, this.compatSources)).map((b) => join(b, "skills"))
     ] : [this.skillsDir];
+    this.skills = this.mergeInline(await this.discoverFrom([...ownRoots, ...this.bundledDirs]));
+  }
+  async discoverFrom(roots) {
     const discovered = [];
     const seen = /* @__PURE__ */ new Set();
     for (const root of roots) {
@@ -3205,7 +3409,7 @@ var SkillsManager = class {
         discovered.push(skill);
       }
     }
-    this.skills = this.mergeInline(discovered);
+    return discovered;
   }
   /** M22 — merge inline skills over discovered ones; inline wins on a name conflict. */
   mergeInline(discovered) {
@@ -3213,8 +3417,12 @@ var SkillsManager = class {
     const inlineNames = new Set(this.inline.map((s) => s.name));
     return [...discovered.filter((s) => !inlineNames.has(s.name)), ...this.inline];
   }
+  visible() {
+    const allowed = this.enabled;
+    return allowed === void 0 ? this.skills : this.skills.filter((s) => allowed.includes(s.name));
+  }
   list() {
-    return Promise.resolve(this.skills);
+    return Promise.resolve(this.visible());
   }
   /**
    * SE20 — resolve a skill by name INCLUDING its body. Inline (`createSkill`)
@@ -3223,7 +3431,7 @@ var SkillsManager = class {
    * enabled skill matches (malformed skills were already excluded at discovery).
    */
   async get(name) {
-    const skill = this.skills.find((s) => s.name === name);
+    const skill = this.visible().find((s) => s.name === name);
     if (skill === void 0) return void 0;
     const instructions = typeof skill.instructions === "string" ? skill.instructions : stripSkillFrontmatter(await readFile(skill.source, "utf8"));
     const references = skill.references;
@@ -3333,7 +3541,8 @@ async function resolveSendSkills(inputs, userText, memoryFacts) {
     inputs.settingSourcesIncludeProject,
     settings.skillsDir,
     settings.inline,
-    resolveCompatSources(inputs.options, inputs.workspaceCwd)
+    resolveCompatSources(inputs.options, inputs.workspaceCwd),
+    settings.bundledDirs
   );
   await manager.initialize();
   return { manager, autoInject: settings.autoInject ?? true };
@@ -3352,7 +3561,9 @@ async function buildSystemPromptContext(inputs, userText, memoryFacts, manager =
     // because a caller naming one has already made the decision this field keeps away from the
     // model. Widening it to execution would break the case the field is FOR — a side-effecting
     // skill a human may run and the model may not propose.
-    skills: skills.filter((skill) => skill.disableModelInvocation !== true).map((skill) => ({ name: skill.name, description: skill.description })),
+    skills: skills.filter((skill) => skill.disableModelInvocation !== true).filter(
+      (skill) => skill.requiresBins === void 0 || skill.requiresBins.every((bin) => binaryOnPath(bin))
+    ).map((skill) => ({ name: skill.name, description: skill.description })),
     userMessage: userText,
     memory: memoryFacts.map((fact) => ({ text: fact.text }))
   };
@@ -3648,6 +3859,23 @@ function validateMcpServers(options) {
         { code: "cloud_stdio_cwd_rejected" }
       );
     }
+    rejectUnhonourableAuth(name, config, options.cloud !== void 0);
+  }
+}
+function rejectUnhonourableAuth(name, config, cloud) {
+  const auth = config.auth;
+  if (auth === void 0) return;
+  if (auth.oauth === void 0) {
+    throw new ConfigurationError(
+      `MCP server "${name}" declares auth without auth.oauth, which the SDK cannot honour; use auth.oauth or set an Authorization header`,
+      { code: "mcp_auth_unsupported" }
+    );
+  }
+  if (cloud) {
+    throw new ConfigurationError(
+      `MCP server "${name}" declares auth.oauth, which the SDK cannot run for a cloud agent`,
+      { code: "mcp_auth_unsupported" }
+    );
   }
 }
 function isStdioWithCwd(config) {
@@ -4164,8 +4392,13 @@ function wrapSpan(span, openSpans) {
     setAttribute: (k, v) => safe(() => span.setAttribute(k, redactAttrValue(v)), void 0),
     setAttributes: (attrs) => safe(() => span.setAttributes(redactAttrs(attrs)), void 0),
     addEvent: (name, attrs) => safe(() => span.addEvent(name, attrs ? redactAttrs(attrs) : void 0), void 0),
-    setStatus: (status) => safe(() => span.setStatus(status), void 0),
-    recordException: (err) => safe(() => span.recordException(err), void 0),
+    setStatus: (status) => safe(
+      () => span.setStatus(
+        status.message === void 0 ? status : { ...status, message: redactSecrets(status.message) }
+      ),
+      void 0
+    ),
+    recordException: (err) => safe(() => span.recordException(redactException(err)), void 0),
     end: (endTime) => {
       safe(() => span.end(endTime), void 0);
       openSpans.delete(span);
@@ -4174,6 +4407,18 @@ function wrapSpan(span, openSpans) {
     isRecording: () => safe(() => span.isRecording(), false)
   };
 }
+function redactException(err) {
+  if (typeof err === "string") return redactSecrets(err);
+  if (typeof err !== "object" || err === null) return err;
+  const src = err;
+  const out = {};
+  for (const k of ["name", "code", "message", "stack"]) {
+    const v = src[k];
+    if (typeof v === "string") out[k] = redactSecrets(v);
+    else if (typeof v === "number") out[k] = v;
+  }
+  return out;
+}
 function redactAttrValue(value) {
   if (typeof value !== "string") return value;
   return redactSecrets(value);
@@ -4897,7 +5142,8 @@ function buildSkills(args, out) {
     staticSkills?.inline,
     // #524 — the same declaration the per-send manager reads. Omitting it here would make
     // `agent.skills` disagree with the system prompt about which skills exist.
-    resolveCompatSources(args.options, args.workspaceCwd)
+    resolveCompatSources(args.options, args.workspaceCwd),
+    staticSkills?.bundledDirs
   );
   const localSkills = out.skillsManager;
   out.skills = {
@@ -5137,7 +5383,9 @@ function evaluateBudgetGate(tracker) {
     return {
       allowed: false,
       reason: "custom",
-      detail: `budget_tracker_check_threw: ${message}`
+      detail: `budget_tracker_check_threw: ${message}`,
+      // Keep the thrown value so the run's error can carry it as its cause.
+      cause: error
     };
   }
 }
@@ -5147,11 +5395,12 @@ function createDoomLoopTracker(option) {
   if (option === false) return void 0;
   return new DoomLoopTracker(option);
 }
-var DEFAULT_CONFIG = { softThreshold: 3, hardThreshold: 5 };
-function assertValidThresholds(soft, hard) {
+var DEFAULT_CONFIG = { softThreshold: 3, hardThreshold: 5, churnThreshold: 6 };
+function assertValidThresholds(soft, hard, churn) {
   for (const [label, value] of [
     ["softThreshold", soft],
-    ["hardThreshold", hard]
+    ["hardThreshold", hard],
+    ["churnThreshold", churn]
   ]) {
     if (!Number.isInteger(value) || value < 1) {
       throw new ConfigurationError(
@@ -5188,17 +5437,40 @@ var DoomLoopTracker = class {
   #config;
   #lastSignature = "";
   #count = 0;
+  #lastName = "";
+  #lastResult;
+  #churn = 0;
   constructor(config) {
     const softThreshold = config?.softThreshold ?? DEFAULT_CONFIG.softThreshold;
     const hardThreshold = config?.hardThreshold ?? DEFAULT_CONFIG.hardThreshold;
-    assertValidThresholds(softThreshold, hardThreshold);
-    this.#config = { softThreshold, hardThreshold };
+    const churnThreshold = config?.churnThreshold ?? DEFAULT_CONFIG.churnThreshold;
+    assertValidThresholds(softThreshold, hardThreshold, churnThreshold);
+    this.#config = { softThreshold, hardThreshold, churnThreshold };
   }
   inspect(call) {
     const signature = signatureOf(call);
-    this.#count = signature === this.#lastSignature ? this.#count + 1 : 1;
+    const identical = signature === this.#lastSignature;
+    const churning = !identical && call.name === this.#lastName && call.result !== void 0 && call.result === this.#lastResult;
+    this.#churn = churning ? this.#churn + 1 : 1;
+    this.#lastName = call.name;
+    this.#lastResult = call.result;
+    this.#count = identical ? this.#count + 1 : 1;
     this.#lastSignature = signature;
     const count = this.#count;
+    const churn = this.#churn;
+    const churnHard = this.#config.churnThreshold;
+    if (churn >= churnHard) {
+      return {
+        kind: "hard",
+        message: `Detected argument churn: ${churn} consecutive calls to \`${call.name}\` with different arguments and no change in the result; stopping to avoid a loop.`
+      };
+    }
+    if (churn > 1 && churn === Math.max(2, churnHard - 2)) {
+      return {
+        kind: "soft",
+        message: `Detected argument churn: ${churn} consecutive calls to \`${call.name}\` with different arguments and no change in the result; try a different approach.`
+      };
+    }
     if (count >= this.#config.hardThreshold) {
       return {
         kind: "hard",
@@ -5216,6 +5488,9 @@ var DoomLoopTracker = class {
   reset() {
     this.#lastSignature = "";
     this.#count = 0;
+    this.#lastName = "";
+    this.#lastResult = void 0;
+    this.#churn = 0;
   }
 };
 function firstDoomLoopVerdict(tracker, calls) {
@@ -5460,7 +5735,16 @@ async function initLoopContext(inputs) {
     ),
     buildUserEvent(inputs)
   ]);
-  if (inputs.onLoopEvent !== void 0) events.subscribe(inputs.onLoopEvent);
+  if (inputs.onLoopEvent !== void 0) {
+    const sink = inputs.onLoopEvent;
+    for (const seeded of events) {
+      try {
+        sink(seeded);
+      } catch {
+      }
+    }
+    events.subscribe(sink);
+  }
   const priorMessages = replayMessages(inputs.priorMessages ?? []);
   let memorySystemPromptAdditions;
   if (inputs.memoryProvider !== void 0 && memoryProviderHandle !== void 0) {
@@ -5549,7 +5833,8 @@ async function collectTools(mcp, withheld, sink) {
         inputSchema: tool.inputSchema,
         origin: "mcp",
         mcpServerName: serverName,
-        mcpToolName: tool.name
+        mcpToolName: tool.name,
+        ...client.sequential === true ? { mcpSequential: true } : {}
       });
     }
   }
@@ -5964,6 +6249,42 @@ function stripThinkBlocks(content) {
   return { visible, thinking };
 }
 
+// src/internal/agent-loop/prune-tool-results.ts
+function stubFor(olderThanRounds) {
+  return `[tool result pruned: older than ${olderThanRounds} rounds]`;
+}
+function carriesToolResult(message) {
+  return message.content.some((part) => part.type === "tool_result");
+}
+function stubbed(message, stub) {
+  const content = message.content.map(
+    (part) => part.type === "tool_result" ? { ...part, content: stub } : part
+  );
+  return { ...message, content };
+}
+function pruneToolResultsForRequest(messages, options) {
+  if (options === void 0) return messages;
+  const stub = stubFor(options.olderThanRounds);
+  const out = [...messages];
+  let rounds = 0;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!carriesToolResult(message)) continue;
+    rounds += 1;
+    if (rounds > options.olderThanRounds) out[index] = stubbed(message, stub);
+  }
+  return out;
+}
+function validatePruneToolResults(options) {
+  if (options === void 0) return;
+  const value = options.olderThanRounds;
+  if (typeof value === "number" && Number.isInteger(value) && value >= 1) return;
+  throw new ConfigurationError(
+    `SendOptions.pruneToolResults.olderThanRounds must be an integer of at least 1, got ${String(value)}`,
+    { code: "invalid_prune_tool_results" }
+  );
+}
+
 // src/internal/agent-loop/loop-llm-stream.ts
 function resolveSystemPromptWithMemoryAdditions(systemPrompt, additions) {
   if (additions === void 0 || additions.length === 0) return systemPrompt;
@@ -6052,7 +6373,8 @@ async function streamLlmTurn(inputs, ctx) {
         const key = derivePromptCacheKey(inputs.agentId);
         return key !== void 0 ? { promptCacheKey: key } : {};
       })(),
-      messages: ctx.messages,
+      // B-564: the request gets a pruned copy; ctx.messages stays whole (the transcript is resent from it).
+      messages: pruneToolResultsForRequest(ctx.messages, inputs.pruneToolResults),
       tools: ctx.tools.map(toLlmTool)
     },
     signal
@@ -6499,11 +6821,35 @@ function raceToolExecution(exec, opts) {
 // src/internal/agent-loop/tool-dispatch.ts
 async function dispatchTools(inputs, tools, toolCalls, events, parentSpan) {
   const maxConcurrent = inputs.maxConcurrentTools ?? 4;
-  return mapWithConcurrency(
-    toolCalls,
-    maxConcurrent,
-    (call) => dispatchSingleCall(inputs, tools, call, events, parentSpan)
-  );
+  const units = [];
+  const bySequentialServer = /* @__PURE__ */ new Map();
+  toolCalls.forEach((call, index) => {
+    const tool = tools.find((t) => t.name === call.name);
+    if (tool?.mcpSequential === true && tool.mcpServerName !== void 0) {
+      let unit = bySequentialServer.get(tool.mcpServerName);
+      if (unit === void 0) {
+        unit = { indexes: [] };
+        bySequentialServer.set(tool.mcpServerName, unit);
+        units.push(unit);
+      }
+      unit.indexes.push(index);
+    } else {
+      units.push({ indexes: [index] });
+    }
+  });
+  const results = new Array(toolCalls.length);
+  await mapWithConcurrency(units, maxConcurrent, async (unit) => {
+    for (const index of unit.indexes) {
+      results[index] = await dispatchSingleCall(
+        inputs,
+        tools,
+        toolCalls[index],
+        events,
+        parentSpan
+      );
+    }
+  });
+  return results;
 }
 async function dispatchSingleCall(inputs, tools, call, events, parentSpan) {
   const { call: workingCall, repairs } = applyRepairAndExtractCall(tools, call);
@@ -6880,12 +7226,17 @@ async function runAgentLoop(inputs) {
     const budget = inputs.budget ?? new IterationBudget({ maxIterations: inputs.maxIterations ?? 8 });
     let lastTurnDecision;
     while (budget.shouldContinue()) {
+      injectSteered(ctx, inputs.steerQueue?.drain());
       if (inputs.budgetTracker !== void 0) {
         const decision2 = evaluateBudgetGate(inputs.budgetTracker);
         if (decision2.allowed === false) {
           ctx.finalStatus = "error";
           if (decision2.detail !== void 0) {
-            ctx.error = { message: decision2.detail, code: decision2.reason ?? "budget" };
+            ctx.error = {
+              message: decision2.detail,
+              code: decision2.reason ?? "budget",
+              ...decision2.cause !== void 0 ? { cause: decision2.cause } : {}
+            };
           }
           if (decision2.reason === "iteration_limit") {
             ctx.stoppedAtIterationLimit = true;
@@ -6897,7 +7248,13 @@ async function runAgentLoop(inputs) {
       if (usingGrace) budget.useGraceCall();
       const decision = await runIteration(inputs, ctx);
       lastTurnDecision = decision;
-      if (decision === "done") break;
+      if (decision === "done") {
+        const late = inputs.steerQueue?.drainOrClose() ?? [];
+        if (late.length === 0) break;
+        injectSteered(ctx, late);
+        budget.consume();
+        continue;
+      }
       if (decision === "error") {
         ctx.finalStatus = "error";
         break;
@@ -7025,6 +7382,10 @@ async function finishOrReflect(inputs, ctx, llmOutput) {
   ctx.finalStatus = "finished";
   return "done";
 }
+function injectSteered(ctx, texts) {
+  if (texts === void 0) return;
+  for (const text of texts) ctx.messages.push({ role: "user", content: [{ type: "text", text }] });
+}
 async function runIteration(inputs, ctx) {
   const hookCtx = { agentId: inputs.agentId, runId: inputs.runId };
   await inputs.pluginManager?.runPreLlmCallHooks(hookCtx);
@@ -7038,12 +7399,11 @@ function trackTurnUsage(inputs, llmOutput) {
   const tracker = inputs.budgetTracker;
   if (tracker === void 0) return;
   const model = inputs.model.id ?? "auto";
-  trackEvent(tracker, { tokens: promptTokens(llmOutput), model, type: "input" });
+  trackEvent(tracker, { tokens: llmOutput.inputTokens ?? 0, model, type: "input" });
+  trackEvent(tracker, { tokens: llmOutput.cacheReadTokens ?? 0, model, type: "cache_read" });
+  trackEvent(tracker, { tokens: llmOutput.cacheWriteTokens ?? 0, model, type: "cache_write" });
   trackEvent(tracker, { tokens: llmOutput.outputTokens ?? 0, model, type: "output" });
 }
-function promptTokens(llmOutput) {
-  return (llmOutput.inputTokens ?? 0) + (llmOutput.cacheReadTokens ?? 0) + (llmOutput.cacheWriteTokens ?? 0);
-}
 function trackEvent(tracker, event) {
   if (event.tokens <= 0) return;
   try {
@@ -7102,12 +7462,22 @@ async function continueOrTerminate(inputs, ctx, llmOutput) {
     }
   }
   pushToolConversationSteps(ctx, llmOutput.toolCalls, toolResults);
-  if (await inspectDoomLoop(inputs, ctx, llmOutput.toolCalls) === "stop") return "done";
+  if (await inspectDoomLoop(inputs, ctx, llmOutput.toolCalls, toolResults) === "stop")
+    return "done";
   return handleToolErrorContinuation(inputs, ctx, toolResults);
 }
-async function inspectDoomLoop(inputs, ctx, toolCalls) {
+async function inspectDoomLoop(inputs, ctx, toolCalls, toolResults) {
   if (ctx.doomLoop === void 0) return "continue";
-  const verdict = firstDoomLoopVerdict(ctx.doomLoop, toolCalls);
+  const resultById = /* @__PURE__ */ new Map();
+  for (const part of toolResults) {
+    if (part.type === "tool_result") {
+      resultById.set(part.toolUseId, JSON.stringify([part.content, part.isError === true]));
+    }
+  }
+  const verdict = firstDoomLoopVerdict(
+    ctx.doomLoop,
+    toolCalls.map((c) => ({ name: c.name, input: c.input, result: resultById.get(c.id) }))
+  );
   if (verdict.kind === "hard") {
     ctx.stoppedByDoomLoop = true;
     await emitAssistantTextStep(
@@ -7184,6 +7554,34 @@ function handshakeAwareTimeout(input) {
   return isReconnectHandshake ? Math.max(input.requestTimeoutMs, HANDSHAKE_FLOOR_MS) : input.requestTimeoutMs;
 }
 
+// src/internal/mcp/oauth-bearer.ts
+var EXPIRY_SKEW_MS = 3e4;
+async function obtain(serverName, clientId, scopes, oauth) {
+  const stored = await getTokens(serverName);
+  if (stored?.accessToken !== void 0 && stored.expiresAt - EXPIRY_SKEW_MS > Date.now()) {
+    return stored;
+  }
+  const refreshToken = stored?.refreshToken;
+  if (refreshToken !== void 0) {
+    try {
+      return await lockedRefresh(
+        serverName,
+        () => refreshAccessToken(serverName, clientId, refreshToken, oauth)
+      );
+    } catch {
+    }
+  }
+  const fresh = await runPkceFlow(serverName, clientId, scopes, oauth);
+  await setTokens(serverName, fresh);
+  return fresh;
+}
+async function resolveBearer(serverName, auth) {
+  if (auth.oauth === void 0)
+    throw new Error(`MCP server "${serverName}" declares no auth.oauth`);
+  const tokens = await obtain(serverName, auth.CLIENT_ID, auth.scopes, auth.oauth);
+  return `Bearer ${tokens.accessToken}`;
+}
+
 // src/internal/mcp/client.ts
 function createMcpClient(name, config, fetchImpl = fetch) {
   if (isStdio(config)) return new StdioMcpClient(name, config);
@@ -7264,6 +7662,9 @@ var StdioMcpClient = class extends BaseMcpClient {
   reconnectPromise;
   /** True only while `reconnect()`'s handshake is in flight — see `timeoutFor`. */
   reconnecting = false;
+  get sequential() {
+    return this.config.sequential === true;
+  }
   get timeoutMs() {
     return this.config.requestTimeoutMs ?? DEFAULT_MCP_TIMEOUT_MS;
   }
@@ -7470,6 +7871,9 @@ var HttpMcpClient = class extends BaseMcpClient {
    */
   sessionId;
   fetchImpl;
+  get sequential() {
+    return this.config.sequential === true;
+  }
   close() {
     return Promise.resolve();
   }
@@ -7482,7 +7886,9 @@ var HttpMcpClient = class extends BaseMcpClient {
    * override contract predates this change and is the only escape a user has while a server
    * misbehaves.
    */
-  buildHeaders() {
+  async buildHeaders() {
+    const auth = this.config.auth;
+    const bearer = auth?.oauth !== void 0 ? await resolveBearer(this.name, auth) : void 0;
     return {
       "content-type": "application/json",
       // Streamable HTTP asks for BOTH media types. Declaring only `application/json` makes a
@@ -7491,6 +7897,7 @@ var HttpMcpClient = class extends BaseMcpClient {
       // Present only for a STATEFUL server. For a stateless one nothing is sent — inventing a
       // header would trade one broken transport for another.
       ...this.sessionId !== void 0 ? { "mcp-session-id": this.sessionId } : {},
+      ...bearer !== void 0 ? { authorization: bearer } : {},
       ...this.config.headers ?? {}
     };
   }
@@ -7533,7 +7940,7 @@ var HttpMcpClient = class extends BaseMcpClient {
   async request(method, params) {
     const id = this.nextId++;
     const payload = { jsonrpc: "2.0", id, method, params };
-    const headers = this.buildHeaders();
+    const headers = await this.buildHeaders();
     const timeoutMs = this.config.requestTimeoutMs ?? DEFAULT_MCP_TIMEOUT_MS;
     let response;
     try {
@@ -7795,6 +8202,13 @@ function createRealLocalRun(options) {
   registerRun(handle);
   return handle;
 }
+function toolResultPolicyInputs(sendOptions) {
+  return {
+    ...sendOptions.perToolTimeoutMs !== void 0 ? { perToolTimeoutMs: sendOptions.perToolTimeoutMs } : {},
+    ...sendOptions.toolResultGuard !== void 0 ? { toolResultGuard: sendOptions.toolResultGuard } : {},
+    ...sendOptions.pruneToolResults !== void 0 ? { pruneToolResults: sendOptions.pruneToolResults } : {}
+  };
+}
 function buildLoopInputs(options, runId, userText, userImages) {
   const maxIterations = options.sendOptions.maxIterations;
   if (maxIterations !== void 0 && (!Number.isInteger(maxIterations) || maxIterations < 1)) {
@@ -7803,6 +8217,7 @@ function buildLoopInputs(options, runId, userText, userImages) {
       { code: "invalid_max_iterations" }
     );
   }
+  validatePruneToolResults(options.sendOptions.pruneToolResults);
   const { primary, effectiveModelId } = resolveRunProvider(options);
   const fallback = options.agentOptions.providers?.fallback;
   const apiKeys = mergeExplicitApiKey(
@@ -7872,10 +8287,8 @@ function buildLoopInputs(options, runId, userText, userImages) {
     ...options.sendOptions.context !== void 0 ? { context: options.sendOptions.context } : {},
     // SE2 — forward the opt-in typed runtime-event sink to the loop.
     ...options.sendOptions.onRunEvent !== void 0 ? { runEventSink: options.sendOptions.onRunEvent } : {},
-    // #58 / #57 — forward the per-tool timeout + tool-result guard so a consumer
-    // can enable them via SendOptions (not only internal AgentLoopInputs).
-    ...options.sendOptions.perToolTimeoutMs !== void 0 ? { perToolTimeoutMs: options.sendOptions.perToolTimeoutMs } : {},
-    ...options.sendOptions.toolResultGuard !== void 0 ? { toolResultGuard: options.sendOptions.toolResultGuard } : {},
+    ...options.steerQueue !== void 0 ? { steerQueue: options.steerQueue } : {},
+    ...toolResultPolicyInputs(options.sendOptions),
     // M1-2: per-send iteration ceiling (validated above). The loop reads
     // inputs.maxIterations (default 8 when unset).
     ...maxIterations !== void 0 ? { maxIterations } : {},
@@ -8096,7 +8509,8 @@ function buildRealRunOptions(args) {
     ...args.priorMessages.length > 0 ? { priorMessages: args.priorMessages } : {},
     ...args.memoryTools !== void 0 && args.memoryTools.length > 0 ? { memoryTools: args.memoryTools } : {},
     ...args.personalityToolWhitelist !== void 0 ? { personalityToolWhitelist: args.personalityToolWhitelist } : {},
-    ...args.personalityName !== void 0 ? { personalityName: args.personalityName } : {}
+    ...args.personalityName !== void 0 ? { personalityName: args.personalityName } : {},
+    ...args.steerQueue !== void 0 ? { steerQueue: args.steerQueue } : {}
   };
 }
 async function createFixtureRunHelper(args) {
@@ -8128,6 +8542,7 @@ async function dispatchLocalRun(args) {
         systemPrompt: args.systemPrompt,
         priorMessages: args.priorMessages,
         memoryTools: args.memoryTools,
+        ...args.steerQueue !== void 0 ? { steerQueue: args.steerQueue } : {},
         ...args.activePreset?.tools !== void 0 ? { personalityToolWhitelist: args.activePreset.tools } : {},
         ...args.activePreset !== void 0 ? { personalityName: args.activePreset.name } : {}
       })
@@ -8180,177 +8595,6 @@ async function consumePending(agentId, pending, clear, refresh) {
   await applyDeferredInvalidation(agentId, pending, refresh);
 }
 
-// src/internal/runtime/registry/live-agent-registry.ts
-var DEFAULT_MAX_AGENTS = 100;
-var DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
-var DEFAULT_SWEEP_INTERVAL_MS = 6e4;
-var LiveAgentRegistry = class {
-  #agents = /* @__PURE__ */ new Map();
-  #maxAgents = DEFAULT_MAX_AGENTS;
-  #idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS;
-  #sweepIntervalMs = DEFAULT_SWEEP_INTERVAL_MS;
-  #onEvict;
-  #sweepTimer;
-  /**
-   * Reconfigure registry behavior. Process-wide singleton (D310) — last
-   * configure call wins for all subsequent operations.
-   */
-  configure(opts) {
-    if (opts.maxAgents !== void 0) this.#maxAgents = Math.max(0, opts.maxAgents);
-    if (opts.idleTimeoutMs !== void 0) this.#idleTimeoutMs = Math.max(0, opts.idleTimeoutMs);
-    if (opts.sweepIntervalMs !== void 0)
-      this.#sweepIntervalMs = Math.max(1e3, opts.sweepIntervalMs);
-    this.#onEvict = opts.onEvict;
-    this.#stopSweep();
-    if (this.#idleTimeoutMs > 0) this.#startSweep();
-  }
-  /**
-   * Lookup a cached agent. `get` is a use — refreshes `lastUsedAt` so the
-   * entry survives LRU eviction.
-   */
-  get(id) {
-    const entry = this.#agents.get(id);
-    if (entry === void 0) return void 0;
-    entry.lastUsedAt = Date.now();
-    return entry.agent;
-  }
-  /**
-   * Insert or overwrite an agent in the cache. Triggers fire-and-forget LRU
-   * eviction when `size > maxAgents`.
-   *
-   * EC-4: when `id` already maps to a DIFFERENT agent instance, dispose the
-   * old one before overwriting (race protection against two `getOrCreate`
-   * calls creating two agents but only the second being cached — the first
-   * would leak file handles + lifecycle controllers).
-   */
-  set(id, agent) {
-    if (this.#maxAgents === 0) return;
-    const existing = this.#agents.get(id);
-    if (existing !== void 0 && existing.agent !== agent) {
-      void existing.agent.dispose().catch(() => {
-        diag(`[theokit-sdk] dispose during overwrite failed (${id})
-`);
-      });
-    }
-    this.#agents.set(id, { agent, lastUsedAt: Date.now() });
-    if (this.#agents.size > this.#maxAgents) void this.#evictLRU();
-  }
-  /**
-   * Remove the entry from the cache WITHOUT calling `dispose()` or
-   * `onEvict`. Used by `LocalAgent.dispose()` itself so the disposed
-   * instance can never be returned by a subsequent `get(id)` (dispose-cache
-   * race fix). Idempotent — calling on an unknown id is a no-op.
-   *
-   * @internal
-   */
-  forget(id) {
-    this.#agents.delete(id);
-  }
-  /**
-   * Explicitly evict an agent by id. Returns `true` when the entry was
-   * present (false = already gone). Calls `agent.dispose()` + `onEvict`
-   * with reason `"explicit"`.
-   */
-  async evict(id) {
-    const entry = this.#agents.get(id);
-    if (entry === void 0) return false;
-    this.#agents.delete(id);
-    await this.#disposeAndNotify(id, entry.agent, "explicit");
-    return true;
-  }
-  /**
-   * Evict every cached agent. Used by graceful shutdown (`process.on('SIGTERM')`)
-   * or end-of-test cleanup.
-   */
-  async evictAll() {
-    const entries = Array.from(this.#agents.entries());
-    this.#agents.clear();
-    this.#stopSweep();
-    for (const [id, entry] of entries) {
-      await this.#disposeAndNotify(id, entry.agent, "explicit");
-    }
-  }
-  /** Number of currently cached agents. */
-  size() {
-    return this.#agents.size;
-  }
-  /** Ids of cached agents, newest first (by lastUsedAt). */
-  ids() {
-    return Array.from(this.#agents.entries()).sort((a, b) => b[1].lastUsedAt - a[1].lastUsedAt).map(([id]) => id);
-  }
-  /**
-   * LRU eviction: drop the entry with the smallest `lastUsedAt`. Runs only
-   * when `size > maxAgents`. Asynchronous because `dispose()` is a Promise;
-   * the hot-path caller (`set`) does not await.
-   *
-   * @internal
-   */
-  async #evictLRU() {
-    if (this.#agents.size <= this.#maxAgents) return;
-    let oldestId;
-    let oldestAt = Infinity;
-    for (const [id, entry2] of this.#agents) {
-      if (entry2.lastUsedAt < oldestAt) {
-        oldestAt = entry2.lastUsedAt;
-        oldestId = id;
-      }
-    }
-    if (oldestId === void 0) return;
-    const entry = this.#agents.get(oldestId);
-    if (entry === void 0) return;
-    this.#agents.delete(oldestId);
-    await this.#disposeAndNotify(oldestId, entry.agent, "lru");
-  }
-  /** Background sweep — drops entries whose `lastUsedAt < now - idleTimeoutMs`. */
-  async #sweepIdle() {
-    if (this.#idleTimeoutMs === 0) return;
-    const threshold = Date.now() - this.#idleTimeoutMs;
-    const toEvict = [];
-    for (const [id, entry] of this.#agents) {
-      if (entry.lastUsedAt < threshold) toEvict.push([id, entry]);
-    }
-    for (const [id, entry] of toEvict) {
-      const current = this.#agents.get(id);
-      if (current === void 0 || current.agent !== entry.agent) continue;
-      this.#agents.delete(id);
-      await this.#disposeAndNotify(id, entry.agent, "idle");
-    }
-  }
-  #startSweep() {
-    this.#sweepTimer = setInterval(() => void this.#sweepIdle(), this.#sweepIntervalMs);
-    this.#sweepTimer.unref?.();
-  }
-  #stopSweep() {
-    if (this.#sweepTimer !== void 0) {
-      clearInterval(this.#sweepTimer);
-      this.#sweepTimer = void 0;
-    }
-  }
-  /** Dispose + notify with errors swallowed (D309). Single chokepoint. */
-  async #disposeAndNotify(id, agent, reason) {
-    try {
-      await agent.dispose();
-    } catch (cause) {
-      const msg = cause instanceof Error ? cause.message : String(cause);
-      diag(`[theokit-sdk] dispose during eviction failed (${id}): ${msg}
-`);
-    }
-    if (this.#onEvict !== void 0) {
-      try {
-        this.#onEvict(id, reason);
-      } catch (cause) {
-        const msg = cause instanceof Error ? cause.message : String(cause);
-        diag(`[theokit-sdk] onEvict listener threw (${id}): ${msg}
-`);
-      }
-    }
-  }
-};
-var liveAgentRegistry = globalSingleton(
-  "theokit-sdk.runtime.live-agents",
-  () => new LiveAgentRegistry()
-);
-
 // src/internal/local-agent/local-agent-lifecycle.ts
 async function acquireLeaseIfPossible(store, agentId) {
   if (typeof store.acquire !== "function") return;
@@ -10069,6 +10313,14 @@ async function applyInputProcessors(inputs, message, rawUserText, options, sendM
   const effectiveMessage = typeof message === "string" ? res.value : { ...message, text: res.value };
   return { userText: res.value, effectiveMessage };
 }
+var lastSendAt = /* @__PURE__ */ new Map();
+function applyIdleReset(agentId, minutes) {
+  const now = Date.now();
+  const previous = lastSendAt.get(agentId);
+  lastSendAt.set(agentId, now);
+  if (minutes === void 0 || !Number.isFinite(minutes) || minutes <= 0) return;
+  if (previous !== void 0 && now - previous > minutes * 6e4) clearSession(agentId);
+}
 async function executeSendLocked(inputs, message, options) {
   if (inputs.disposed) throw new AgentDisposedError(inputs.agentId);
   await consumePending(
@@ -10083,6 +10335,7 @@ async function executeSendLocked(inputs, message, options) {
   const gated = await applyInputProcessors(inputs, message, rawUserText, options, sendModel);
   if ("tripwireRun" in gated) return gated.tripwireRun;
   const { userText, effectiveMessage } = gated;
+  applyIdleReset(inputs.agentId, inputs.options.sessionIdleResetMinutes);
   if (inputs.options.onBeforeSend !== void 0) {
     await inputs.options.onBeforeSend({
       conversationId: inputs.agentId,
@@ -10268,6 +10521,43 @@ function reportUnknownLocalOptions(local) {
   }
 }
 
+// src/internal/local-agent/send-queue.ts
+var TurnSteerQueue = class {
+  pending = [];
+  closed = false;
+  /** @returns false when the turn can no longer pick the message up. */
+  push(text) {
+    if (this.closed) return false;
+    this.pending.push(text);
+    return true;
+  }
+  drain() {
+    const taken = this.pending;
+    this.pending = [];
+    return taken;
+  }
+  drainOrClose() {
+    const taken = this.drain();
+    if (taken.length === 0) this.closed = true;
+    return taken;
+  }
+  /** Stop accepting and hand back what no loop iteration picked up. */
+  closeAndTake() {
+    this.closed = true;
+    return this.drain();
+  }
+};
+function joinCollected(messages) {
+  if (messages.length === 1) return messages[0];
+  const texts = messages.map((m) => typeof m === "string" ? m : m.text);
+  const images = messages.flatMap((m) => typeof m === "string" ? [] : m.images ?? []);
+  const text = texts.join("\n\n");
+  return images.length > 0 ? { text, images } : text;
+}
+function hasImages(message) {
+  return typeof message !== "string" && (message.images?.length ?? 0) > 0;
+}
+
 // src/internal/local-agent/local-agent.ts
 var LocalAgent = class {
   /**
@@ -10316,6 +10606,9 @@ var LocalAgent = class {
   settingSourcesIncludePlugins;
   resolvedSubagents = {};
   disposed = false;
+  activeTurn;
+  inflight = 0;
+  collectBatch;
   invalidationPending;
   skillsManager;
   pluginsManager;
@@ -10440,10 +10733,48 @@ var LocalAgent = class {
       agentId: this.agentId,
       ...this.model?.id !== void 0 ? { model: this.model.id } : {}
     });
+    return this.enqueueSend(message, options, sendSpan);
+  }
+  /** Queue one send behind the lock, or fold it into the running turn / pending batch. */
+  enqueueSend(message, options, sendSpan) {
+    const mode = options.queueMode ?? "followup";
+    const text = typeof message === "string" ? message : message.text;
+    const active = this.activeTurn;
+    if (mode === "steer" && active !== void 0 && !hasImages(message) && active.steer.push(text)) {
+      sendSpan.end();
+      return active.run;
+    }
+    if (mode === "collect" && this.collectBatch !== void 0) {
+      this.collectBatch.messages.push(message);
+      sendSpan.end();
+      return this.collectBatch.run;
+    }
+    const key = `agent-send:${this.agentId}`;
+    this.inflight += 1;
+    const release = () => {
+      this.inflight -= 1;
+    };
+    if (mode === "collect" && this.inflight > 1) {
+      const messages = [message];
+      const run = new Promise((resolve, reject) => {
+        void withCwdMutex(key, () => {
+          this.collectBatch = void 0;
+          return this.runLockedSendCycle(
+            joinCollected(messages),
+            options,
+            sendSpan,
+            resolve,
+            reject
+          ).finally(release);
+        });
+      });
+      this.collectBatch = { messages, run };
+      return run;
+    }
     return new Promise((resolve, reject) => {
       void withCwdMutex(
-        `agent-send:${this.agentId}`,
-        () => this.runLockedSendCycle(message, options, sendSpan, resolve, reject)
+        key,
+        () => this.runLockedSendCycle(message, options, sendSpan, resolve, reject).finally(release)
       );
     });
   }
@@ -10459,20 +10790,40 @@ var LocalAgent = class {
     const declared = this.model?.contextWindow;
     return declared !== void 0 ? { contextWindow: declared } : {};
   }
+  /** A steered message the loop never picked up (run errored, was cancelled) still gets answered. */
+  followUpUnsteered(leftover) {
+    if (leftover.length === 0) return;
+    this.send(leftover.join("\n\n")).catch(
+      (err) => diagFailure(`[theokit-sdk] steered message followup failed: ${String(err)}`)
+    );
+  }
   async runLockedSendCycle(message, options, sendSpan, resolve, reject) {
     const userText = typeof message === "string" ? message : message.text;
     let run;
+    const steer = new TurnSteerQueue();
+    let res = () => void 0;
+    let rej = () => void 0;
+    const turnRun = new Promise((a, b) => {
+      res = a;
+      rej = b;
+    });
+    turnRun.catch(() => void 0);
+    this.activeTurn = { steer, run: turnRun };
     try {
       run = await this.sendLocked(message, options);
     } catch (err) {
       sendSpan.recordException(err);
       sendSpan.setStatus({ code: 2, message: err instanceof Error ? err.message : String(err) });
       sendSpan.end();
+      this.activeTurn = void 0;
+      rej(err);
       reject(err);
       return;
     }
     if (options.task !== void 0) registerRunAsTask(run, this.agentId, options.task, userText);
-    resolve(callerView(run, this.options.throwOnError));
+    const view = callerView(run, this.options.throwOnError);
+    res(view);
+    resolve(view);
     try {
       await runPostRunLifecycle({
         run,
@@ -10496,6 +10847,8 @@ var LocalAgent = class {
       });
     } finally {
       sendSpan.end();
+      this.activeTurn = void 0;
+      this.followUpUnsteered(steer.closeAndTake());
     }
   }
   async sendLocked(message, options) {
@@ -10603,11 +10956,13 @@ var LocalAgent = class {
       memoryFacts,
       priorMessages,
       memoryTools,
-      activePreset: this.activePreset()
+      activePreset: this.activePreset(),
+      ...this.activeTurn !== void 0 ? { steerQueue: this.activeTurn.steer } : {}
     });
   }
   close() {
     this.disposed = true;
+    liveAgentRegistry.forget(this.agentId);
   }
   async reload() {
     this.resolvedSubagents = await reloadLocalAgent(this);
@@ -10958,6 +11313,7 @@ function paginateByKey(all, keyOf, limit, cursor, sortByKey) {
 
 // src/agent.ts
 var streamObjectImport;
+var getOrCreateInFlight = /* @__PURE__ */ new Map();
 var Agent = class _Agent {
   constructor() {
   }
@@ -11142,7 +11498,7 @@ var Agent = class _Agent {
    * @public
    */
   static async batch(prompts, options) {
-    const { batchImpl } = await import('./batch-EP3FCL6D.js');
+    const { batchImpl } = await import('./batch-N2XDYZED.js');
     return batchImpl(prompts, options, { create: (opts) => _Agent.create(opts) });
   }
   /**
@@ -11172,18 +11528,27 @@ var Agent = class _Agent {
    *   The agent-builder's M85 interrupt rotates the session id to work around a
    *   constraint that does not exist.
    *
-   * - `close()` marks the handle disposed WITHOUT evicting the cache entry. It is
-   *   internal and unused today; if it becomes reachable, this bullet stops being true
-   *   for that path.
+   * - `close()` marks the handle disposed AND drops its cache entry, so the next call
+   *   builds a fresh handle.
    *
    * @public
    */
   static async getOrCreate(agentId, options) {
     const cached = _Agent.registry.get(agentId);
     if (cached !== void 0) return cached;
-    const fresh = await getOrCreateUncached(agentId, options);
-    _Agent.registry.set(agentId, fresh);
-    return fresh;
+    const inFlight = getOrCreateInFlight.get(agentId);
+    if (inFlight !== void 0) return inFlight;
+    const build = (async () => {
+      const fresh = await getOrCreateUncached(agentId, options);
+      _Agent.registry.set(agentId, fresh);
+      return fresh;
+    })();
+    getOrCreateInFlight.set(agentId, build);
+    try {
+      return await build;
+    } finally {
+      if (getOrCreateInFlight.get(agentId) === build) getOrCreateInFlight.delete(agentId);
+    }
   }
   /**
    * List agents (local or cloud). M107 — `cwd` is READ, not ignored. B-115 (2026-08-19) —
@@ -11294,7 +11659,7 @@ var Agent = class _Agent {
    */
   static async compact(agentId, options = {}) {
     const reg = await requireLocalAgent(agentId, "compact");
-    const { compactSessionTranscript, buildDefaultSummarizer: buildDefaultSummarizer2 } = await import('./compact-session-5HMX6KYT.js');
+    const { compactSessionTranscript, buildDefaultSummarizer: buildDefaultSummarizer2 } = await import('./compact-session-Q5IGNFPW.js');
     const { cwd, model, store } = await openLocalStore(reg);
     return enqueueSessionWrite(
       cwd,
@@ -11324,7 +11689,7 @@ var Agent = class _Agent {
    */
   static async injectSessionTurn(agentId, turn) {
     const reg = await requireLocalAgent(agentId, "injectSessionTurn");
-    const { injectSessionTurn } = await import('./inject-session-75L3NCNL.js');
+    const { injectSessionTurn } = await import('./inject-session-4ROYLZHY.js');
     const { cwd, model, store } = await openLocalStore(reg);
     await injectSessionTurn({
       store,
@@ -11375,7 +11740,7 @@ var Agent = class _Agent {
    */
   static async describe(agentId) {
     const agent = await getRegisteredAgentOrThrow(agentId);
-    const { loadSubagents: loadSubagents2 } = await import('./subagents-loader-Z744TAKD.js');
+    const { loadSubagents: loadSubagents2 } = await import('./subagents-loader-SXETS2F2.js');
     const settingSources = agent.options.local?.settingSources;
     const subagents = await loadSubagents2(
       agent.cwd ?? process.cwd(),
@@ -11474,7 +11839,9 @@ async function openLocalStore(reg) {
   const cwd = reg.cwd ?? process.cwd();
   const optModel = reg.options.model;
   const model = reg.model?.id ?? (typeof optModel === "string" ? optModel : optModel?.id) ?? "unknown";
-  const { FsSessionStore: FsSessionStore2 } = await import('./fs-session-store-6ZCCJX3K.js');
+  const injected = reg.options.local?.sessionStore;
+  if (injected !== void 0) return { cwd, model, store: injected };
+  const { FsSessionStore: FsSessionStore2 } = await import('./fs-session-store-MYQEVUFL.js');
   const { defaultBaseDir: defaultBaseDir2, expandTilde: expandTilde2 } = await import('./session-transcript-BSHZYYY6.js');
   const configuredSessionDir = reg.options.local?.sessionDir ?? reg.options.local?.baseDir;
   const baseDir = configuredSessionDir !== void 0 ? expandTilde2(configuredSessionDir) : defaultBaseDir2();
@@ -11482,5 +11849,5 @@ async function openLocalStore(reg) {
 }
 
 export { Agent, AgentBuilder, DEFAULT_AGENTIC_MODEL_ID, MEMORY_EMBEDDING_ADAPTERS, Tool, ToolError, UsageAccumulator, computeCost, generateCronId, getPricingEntry, managedSettingsPathFor, openRouterMemoryEmbeddingProviderAdapter, readManagedSettings, resolveSessionDir };
-//# sourceMappingURL=chunk-JX4LB6XO.js.map
-//# sourceMappingURL=chunk-JX4LB6XO.js.map
+//# sourceMappingURL=chunk-5M5GQYBM.js.map
+//# sourceMappingURL=chunk-5M5GQYBM.js.map