@rowan-agent/agent 0.15.4 → 0.16.0

package/dist/index.js

@@ -1247,6 +1247,56 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
       assertActive();
       hooks?.off(eventType, handler);
     },
+    config: {
+      get: async (scope) => {
+        assertActive();
+        return await options?.config?.get(scope) ?? null;
+      },
+      changed: (handler) => {
+        assertActive();
+        options?.config?.changed(handler);
+      }
+    },
+    state: {
+      run: (runId) => {
+        assertActive();
+        const store = options?.state?.run(runId);
+        return {
+          get: async (key) => {
+            assertActive();
+            return store?.get(key);
+          },
+          set: async (key, value) => {
+            assertActive();
+            assertJsonValue(value);
+            return store?.set(key, value);
+          },
+          delete: async (key) => {
+            assertActive();
+            return store?.delete(key);
+          }
+        };
+      },
+      agent: (agentId) => {
+        assertActive();
+        const store = options?.state?.agent(agentId);
+        return {
+          get: async (key) => {
+            assertActive();
+            return store?.get(key);
+          },
+          set: async (key, value) => {
+            assertActive();
+            assertJsonValue(value);
+            return store?.set(key, value);
+          },
+          delete: async (key) => {
+            assertActive();
+            return store?.delete(key);
+          }
+        };
+      }
+    },
     tool: {
       register: (tool) => {
         assertActive();
@@ -1257,6 +1307,25 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
         options?.unregisterTool?.(toolName);
       }
     },
+    capabilities: {
+      contribute: (contribution) => {
+        assertActive();
+        if (!contribution || typeof contribution !== "object") {
+          throw new TypeError("Capability contribution must be an object.");
+        }
+        if (contribution.kind !== "tool") {
+          throw new TypeError(`Unsupported capability contribution kind: "${contribution.kind}".`);
+        }
+        if (typeof contribution.name !== "string" || contribution.name.trim() === "") {
+          throw new TypeError("Capability contribution requires a non-empty name.");
+        }
+        if (typeof contribution.description !== "string") {
+          throw new TypeError("Capability contribution requires a description string.");
+        }
+        return options?.contributeCapability ? options.contributeCapability(contribution) : () => {
+        };
+      }
+    },
     registerProvider: (config) => {
       assertActive();
       options?.registerProvider?.(config);
@@ -4518,7 +4587,9 @@ function assembleRegisteredExtensions(snapshot, runner, options = {}) {
         agentId: input.context.agentId,
         toolCallId: input.context.toolCallId,
         metadata: input.context.runMetadata,
-        answer: input.answer
+        answer: input.answer,
+        scope: input.context.scope,
+        turn: input.context.turn
       });
       if (decision.interaction !== void 0) {
         return { interaction: decision.interaction };
@@ -4534,7 +4605,9 @@ function assembleRegisteredExtensions(snapshot, runner, options = {}) {
           runId: input.context.runId,
           agentId: input.context.agentId,
           toolCallId: input.context.toolCallId,
-          metadata: input.context.runMetadata
+          metadata: input.context.runMetadata,
+          scope: input.context.scope,
+          turn: input.context.turn
         }
       );
       return fromLoopResult(result);
@@ -4792,6 +4865,126 @@ var HooksManager = class {
   }
 };
 
+// src/extensions/host.ts
+var InMemoryExtensionHost = class {
+  configs = /* @__PURE__ */ new Map();
+  agentState = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    if (options.configs) {
+      for (const [scopeKey, extMap] of Object.entries(options.configs)) {
+        const map = /* @__PURE__ */ new Map();
+        for (const [extId, cfg] of Object.entries(extMap)) {
+          assertJsonValue(cfg);
+          map.set(extId, structuredClone(cfg));
+        }
+        this.configs.set(scopeKey, map);
+      }
+    }
+    if (options.agentState) {
+      for (const [agentId, extMap] of Object.entries(options.agentState)) {
+        const agentMap = /* @__PURE__ */ new Map();
+        for (const [extId, stateMap] of Object.entries(extMap)) {
+          const map = /* @__PURE__ */ new Map();
+          for (const [key, val] of Object.entries(stateMap)) {
+            assertJsonValue(val);
+            map.set(key, structuredClone(val));
+          }
+          agentMap.set(extId, map);
+        }
+        this.agentState.set(agentId, agentMap);
+      }
+    }
+  }
+  setConfig(extensionId, config, scope = { kind: "global" }) {
+    const scopeKey = scopeToKey(scope);
+    if (!this.configs.has(scopeKey)) {
+      this.configs.set(scopeKey, /* @__PURE__ */ new Map());
+    }
+    const scopeConfigs = this.configs.get(scopeKey);
+    if (config === null) {
+      scopeConfigs.delete(extensionId);
+    } else {
+      assertJsonValue(config);
+      scopeConfigs.set(extensionId, structuredClone(config));
+    }
+    this.notifyConfigChanged(extensionId, scope);
+  }
+  getConfig(extensionId, scope = { kind: "global" }) {
+    const globalConfig = this.configs.get("global")?.get(extensionId);
+    let merged = globalConfig ? { ...globalConfig } : null;
+    if (scope.kind === "team" || scope.kind === "project") {
+      const teamConfig = this.configs.get(`team:${scope.teamId}`)?.get(extensionId);
+      if (teamConfig) {
+        merged = { ...merged ?? {}, ...teamConfig };
+      }
+    }
+    if (scope.kind === "project") {
+      const projectConfig = this.configs.get(`project:${scope.teamId}:${scope.projectId}`)?.get(extensionId);
+      if (projectConfig) {
+        merged = { ...merged ?? {}, ...projectConfig };
+      }
+    }
+    return merged ? structuredClone(merged) : null;
+  }
+  onConfigChanged(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notifyConfigChanged(extensionId, scope = { kind: "global" }) {
+    for (const listener of this.listeners) {
+      try {
+        listener(extensionId, scope);
+      } catch {
+      }
+    }
+  }
+  getAgentState(extensionId, agentId, key) {
+    const val = this.agentState.get(agentId)?.get(extensionId)?.get(key);
+    return val !== void 0 ? structuredClone(val) : void 0;
+  }
+  setAgentState(extensionId, agentId, key, value) {
+    assertJsonValue(value);
+    let agentMap = this.agentState.get(agentId);
+    if (!agentMap) {
+      agentMap = /* @__PURE__ */ new Map();
+      this.agentState.set(agentId, agentMap);
+    }
+    let extMap = agentMap.get(extensionId);
+    if (!extMap) {
+      extMap = /* @__PURE__ */ new Map();
+      agentMap.set(extensionId, extMap);
+    }
+    extMap.set(key, structuredClone(value));
+  }
+  deleteAgentState(extensionId, agentId, key) {
+    this.agentState.get(agentId)?.get(extensionId)?.delete(key);
+  }
+};
+function scopeToKey(scope) {
+  switch (scope.kind) {
+    case "global":
+      return "global";
+    case "team":
+      return `team:${scope.teamId}`;
+    case "project":
+      return `project:${scope.teamId}:${scope.projectId}`;
+  }
+}
+function resolveScopeFromMetadata(metadata) {
+  if (metadata) {
+    const teamId = typeof metadata.teamId === "string" ? metadata.teamId : void 0;
+    const projectId = typeof metadata.projectId === "string" ? metadata.projectId : void 0;
+    if (teamId && projectId) {
+      return { kind: "project", teamId, projectId };
+    }
+    if (teamId) {
+      return { kind: "team", teamId };
+    }
+  }
+  return { kind: "global" };
+}
+
 // src/extensions/runner.ts
 import { execFile } from "child_process";
 import { dirname as dirname5, resolve as resolve5 } from "path";
@@ -4934,11 +5127,17 @@ var ExtensionRunner = class {
   hooks;
   runtime;
   events;
+  host;
   cwd;
   abortController = new AbortController();
   _idle = true;
   // Per-extension tracking
   extensions = [];
+  // Run state: runId -> extensionId -> key -> value
+  runState = /* @__PURE__ */ new Map();
+  // Config change listeners: extensionId -> Set of handlers
+  configChangeListeners = /* @__PURE__ */ new Map();
+  hostUnsubscribers = [];
   // Phase management
   phases = /* @__PURE__ */ new Map();
   _phaseCache = null;
@@ -4947,6 +5146,8 @@ var ExtensionRunner = class {
   bound = false;
   // Error listeners
   errorListeners = /* @__PURE__ */ new Set();
+  // Capability change listeners
+  capabilityListeners = /* @__PURE__ */ new Set();
   /** Current agent context — set by the agent before each phase */
   currentContext;
   constructor(options) {
@@ -4954,6 +5155,15 @@ var ExtensionRunner = class {
     this.runtime = createExtensionRuntime();
     this.events = createEventBus();
     this.cwd = options?.cwd ?? process.cwd();
+    this.host = options?.host ?? new InMemoryExtensionHost();
+    if (this.host.onConfigChanged) {
+      const unsub = this.host.onConfigChanged((extensionId, scope) => {
+        this.notifyConfigChanged(extensionId, scope);
+      });
+      if (typeof unsub === "function") {
+        this.hostUnsubscribers.push(unsub);
+      }
+    }
   }
   /** Whether the agent is currently idle (not streaming). */
   get isIdle() {
@@ -5034,10 +5244,13 @@ var ExtensionRunner = class {
    */
   async loadExtensions(extensions) {
     for (const ext of extensions) {
+      const extensionId = ext.id ?? ext.manifest?.id ?? ext.name;
       const extension = {
+        id: extensionId,
         path: ext.path,
         tools: /* @__PURE__ */ new Map(),
         phases: /* @__PURE__ */ new Set(),
+        capabilities: /* @__PURE__ */ new Map(),
         cleanup: [],
         runtime: createExtensionRuntime()
       };
@@ -5047,6 +5260,9 @@ var ExtensionRunner = class {
         if (typeof disposer === "function") extension.disposer = disposer;
         this.extensions.push(extension);
         this._phaseCache = null;
+        if (extension.capabilities.size > 0) {
+          this.notifyCapabilitiesChanged();
+        }
       } catch (error) {
         await this.rollbackExtension(extension);
         const message = error instanceof Error ? error.message : String(error);
@@ -5063,14 +5279,67 @@ var ExtensionRunner = class {
   /** Dispose all active Extensions in reverse activation order. */
   async close() {
     this.abortController.abort();
+    for (const unsub of this.hostUnsubscribers) {
+      try {
+        unsub();
+      } catch {
+      }
+    }
+    this.hostUnsubscribers.length = 0;
+    this.configChangeListeners.clear();
+    this.runState.clear();
     for (const extension of [...this.extensions].reverse()) {
       await this.disposeExtension(extension, "This Extension Runtime has been closed.");
     }
     this.extensions.length = 0;
+    this.capabilityListeners.clear();
     this.phases.clear();
     this._phaseCache = null;
     this.runtime.invalidate("This Extension Runtime has been closed.");
   }
+  get extensionHost() {
+    return this.host;
+  }
+  notifyConfigChanged(extensionId, scope) {
+    const listeners = this.configChangeListeners.get(extensionId);
+    if (!listeners) return;
+    for (const listener of listeners) {
+      try {
+        listener(scope);
+      } catch (error) {
+        this.emitError({
+          extensionPath: "<runtime>",
+          event: "config_changed",
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+      }
+    }
+  }
+  getRunState(runId, extensionId, key) {
+    const val = this.runState.get(runId)?.get(extensionId)?.get(key);
+    return val !== void 0 ? structuredClone(val) : void 0;
+  }
+  setRunState(runId, extensionId, key, value) {
+    assertJsonValue(value);
+    let runMap = this.runState.get(runId);
+    if (!runMap) {
+      runMap = /* @__PURE__ */ new Map();
+      this.runState.set(runId, runMap);
+    }
+    let extMap = runMap.get(extensionId);
+    if (!extMap) {
+      extMap = /* @__PURE__ */ new Map();
+      runMap.set(extensionId, extMap);
+    }
+    extMap.set(key, structuredClone(value));
+  }
+  deleteRunState(runId, extensionId, key) {
+    this.runState.get(runId)?.get(extensionId)?.delete(key);
+  }
+  dropRunState(runId) {
+    this.runState.delete(runId);
+  }
   // ---------------------------------------------------------------------------
   // Tool management
   // ---------------------------------------------------------------------------
@@ -5097,6 +5366,32 @@ var ExtensionRunner = class {
     return void 0;
   }
   // ---------------------------------------------------------------------------
+  // Capability management
+  // ---------------------------------------------------------------------------
+  /** Get all contributed capabilities across all extensions. */
+  getCapabilities() {
+    const result = [];
+    for (const ext of this.extensions) {
+      for (const contrib of ext.capabilities.values()) {
+        result.push({
+          extensionId: ext.id,
+          kind: contrib.kind,
+          name: contrib.name,
+          description: contrib.description
+        });
+      }
+    }
+    return Object.freeze(result);
+  }
+  /**
+   * Subscribe to capability changes (contributions added, removed, or extensions disposed).
+   * Returns an unsubscribe function.
+   */
+  onCapabilitiesChanged(listener) {
+    this.capabilityListeners.add(listener);
+    return () => this.capabilityListeners.delete(listener);
+  }
+  // ---------------------------------------------------------------------------
   // Phase management
   // ---------------------------------------------------------------------------
   getPhase(name) {
@@ -5182,7 +5477,39 @@ var ExtensionRunner = class {
     });
     return result?.input ?? input;
   }
+  async emitRunStart(event) {
+    try {
+      await this.hooks.emit("run_start", {
+        type: "run_start",
+        ...event
+      });
+    } catch (error) {
+      this.emitError({
+        extensionPath: "<runtime>",
+        event: "run_start",
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      });
+    }
+  }
+  async emitRunEnd(event) {
+    try {
+      await this.hooks.emit("run_end", {
+        type: "run_end",
+        ...event
+      });
+    } catch (error) {
+      this.emitError({
+        extensionPath: "<runtime>",
+        event: "run_end",
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      });
+    }
+  }
   async emitBeforeToolCall(tool, args, context) {
+    const scope = context?.scope ?? resolveScopeFromMetadata(context?.metadata);
+    const turn = context?.turn ?? {};
     const result = await this.emitHook("before_tool_call", {
       type: "before_tool_call",
       tool,
@@ -5191,11 +5518,15 @@ var ExtensionRunner = class {
       ...context?.agentId !== void 0 ? { agentId: context.agentId } : {},
       ...context?.toolCallId !== void 0 ? { toolCallId: context.toolCallId } : {},
       ...context?.metadata !== void 0 ? { metadata: context.metadata } : {},
-      ...context?.answer !== void 0 ? { answer: context.answer } : {}
+      ...context?.answer !== void 0 ? { answer: context.answer } : {},
+      scope,
+      turn
     });
     return result ?? { allow: true };
   }
   async emitAfterToolCall(tool, result, context) {
+    const scope = context?.scope ?? resolveScopeFromMetadata(context?.metadata);
+    const turn = context?.turn ?? {};
     const hookResult = await this.emitHook("after_tool_call", {
       type: "after_tool_call",
       tool,
@@ -5203,7 +5534,9 @@ var ExtensionRunner = class {
       ...context?.runId !== void 0 ? { runId: context.runId } : {},
       ...context?.agentId !== void 0 ? { agentId: context.agentId } : {},
       ...context?.toolCallId !== void 0 ? { toolCallId: context.toolCallId } : {},
-      ...context?.metadata !== void 0 ? { metadata: context.metadata } : {}
+      ...context?.metadata !== void 0 ? { metadata: context.metadata } : {},
+      scope,
+      turn
     });
     return hookResult?.result ?? result;
   }
@@ -5271,9 +5604,43 @@ var ExtensionRunner = class {
       unregisterProvider: (name) => this.unregisterProvider(name),
       registerTool: (tool) => this.registerTool(extension, tool),
       unregisterTool: (toolName) => this.unregisterTool(extension, toolName),
+      contributeCapability: (contribution) => this.contributeCapability(extension, contribution),
       context: extContext,
       manifest,
-      trackCleanup: (cleanup) => extension.cleanup.push(cleanup)
+      trackCleanup: (cleanup) => extension.cleanup.push(cleanup),
+      config: {
+        get: async (scope) => {
+          const effectiveScope = scope ?? { kind: "global" };
+          const res = await runner.host.getConfig(extension.id, effectiveScope);
+          return res ?? null;
+        },
+        changed: (handler) => {
+          let listeners = runner.configChangeListeners.get(extension.id);
+          if (!listeners) {
+            listeners = /* @__PURE__ */ new Set();
+            runner.configChangeListeners.set(extension.id, listeners);
+          }
+          listeners.add(handler);
+          extension.cleanup.push(() => {
+            listeners?.delete(handler);
+            if (listeners && listeners.size === 0) {
+              runner.configChangeListeners.delete(extension.id);
+            }
+          });
+        }
+      },
+      state: {
+        run: (runId) => ({
+          get: async (key) => runner.getRunState(runId, extension.id, key),
+          set: async (key, value) => runner.setRunState(runId, extension.id, key, value),
+          delete: async (key) => runner.deleteRunState(runId, extension.id, key)
+        }),
+        agent: (agentId) => ({
+          get: async (key) => runner.host.getAgentState(extension.id, agentId, key),
+          set: async (key, value) => runner.host.setAgentState(extension.id, agentId, key, value),
+          delete: async (key) => runner.host.deleteAgentState(extension.id, agentId, key)
+        })
+      }
     }, extension.runtime, this.events);
   }
   registerTool(extension, tool) {
@@ -5302,6 +5669,46 @@ var ExtensionRunner = class {
       extension.tools.delete(toolName);
     }
   }
+  contributeCapability(extension, contribution) {
+    const key = `${contribution.kind}:${contribution.name}`;
+    const entry = {
+      kind: contribution.kind,
+      name: contribution.name,
+      description: contribution.description
+    };
+    extension.capabilities.set(key, entry);
+    if (this.extensions.includes(extension)) {
+      this.notifyCapabilitiesChanged();
+    }
+    let disposed = false;
+    const dispose = () => {
+      if (disposed) return;
+      disposed = true;
+      if (extension.capabilities.get(key) === entry) {
+        extension.capabilities.delete(key);
+        if (this.extensions.includes(extension)) {
+          this.notifyCapabilitiesChanged();
+        }
+      }
+    };
+    extension.cleanup.push(dispose);
+    return dispose;
+  }
+  notifyCapabilitiesChanged() {
+    const capabilities = this.getCapabilities();
+    for (const listener of this.capabilityListeners) {
+      try {
+        listener(capabilities);
+      } catch (error) {
+        this.emitError({
+          extensionPath: "<runtime>",
+          event: "capabilities_changed",
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+      }
+    }
+  }
   async registerPhase(extension, registration) {
     if (typeof registration === "string") {
       if (registration.length === 0) {
@@ -5388,6 +5795,8 @@ var ExtensionRunner = class {
   async disposeExtension(extension, message) {
     extension.runtime.invalidate(message);
     for (const name of extension.phases) this.phases.delete(name);
+    const hadCapabilities = extension.capabilities.size > 0;
+    extension.capabilities.clear();
     for (const cleanup of [...extension.cleanup].reverse()) {
       await Promise.resolve().then(() => cleanup()).catch(() => void 0);
     }
@@ -5395,6 +5804,9 @@ var ExtensionRunner = class {
       await Promise.resolve().then(() => extension.disposer()).catch(() => void 0);
     }
     this._phaseCache = null;
+    if (hadCapabilities) {
+      this.notifyCapabilitiesChanged();
+    }
   }
 };
 function createExtensionRunner(options) {
@@ -5425,6 +5837,8 @@ function readManifestSync(dir) {
     const rowan = pkg.rowan;
     if (!rowan) return void 0;
     return {
+      id: rowan.id ?? pkg.name,
+      name: pkg.name,
       entry: rowan.extensions?.[0]
     };
   } catch {
@@ -5507,13 +5921,15 @@ async function discoverExtensionsInDir(dir) {
   }
   return paths;
 }
-function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>") {
+function loadExtensionFromFactory(factory, cwd, extensionPath = "<inline>", options = {}) {
   const resolvedCwd = resolve6(cwd);
   const resolvedPath = isSyntheticPath(extensionPath) ? extensionPath : resolve6(resolvedCwd, extensionPath);
-  const name = isSyntheticPath(extensionPath) ? extensionPath : basename3(dirname6(resolvedPath)) || "unknown";
+  const name = options.name ?? (isSyntheticPath(extensionPath) ? extensionPath : basename3(dirname6(resolvedPath)) || "unknown");
   const manifestDir = isSyntheticPath(extensionPath) ? resolvedCwd : dirname6(resolvedPath);
   const manifest = readManifestSync(manifestDir);
+  const id = options.id ?? manifest?.id ?? name;
   return {
+    id,
     path: resolvedPath,
     name,
     factory,
@@ -5983,6 +6399,12 @@ var RuntimeExtensionLifetime = class {
   get extensionRunner() {
     return this.runner;
   }
+  get extensionHost() {
+    return this.runner.extensionHost;
+  }
+  dropRunState(runId) {
+    this.runner.dropRunState(runId);
+  }
   async close() {
     if (this.closed) return;
     this.closed = true;
@@ -5996,6 +6418,9 @@ var RuntimeBootstrapRegistry = class extends ResourceRegistry {
   }
   extensions;
   extensionSourceId = "rowan.extensions";
+  get extensionHost() {
+    return this.extensions.extensionHost;
+  }
   /** Install Rowan-owned implicit resources before any host source is read. */
   async ensureCoreResources() {
     await this.replaceImplicit("tool", "rowan.core", [createRouteTool([])]);
@@ -6134,11 +6559,14 @@ var AgentRuntime = class _AgentRuntime {
   autoCompactionRuns = /* @__PURE__ */ new Set();
   consumers = /* @__PURE__ */ new Map();
   transientEvents = new TransientRunEventHub();
+  host;
   resources;
+  startedRuns = /* @__PURE__ */ new Set();
   heartbeat;
   pumping = false;
   closed = false;
   constructor(options, owned, resources) {
+    this.host = options.host;
     this.owned = owned;
     this.commands = new ConfigCommandService(owned, options.configs, String(owned.lease.token).split(":")[0]);
     this.storeIncarnation = String(owned.lease.token).split(":")[0];
@@ -6148,10 +6576,12 @@ var AgentRuntime = class _AgentRuntime {
   static async init(options) {
     if (!options.store) throw new TypeError("AgentRuntime requires a DurableStore");
     const configs = options.configs ?? new InMemoryConfigProvider();
+    const host = options.host ?? new InMemoryExtensionHost();
     const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
     if (!Number.isInteger(concurrency) || concurrency <= 0) throw new TypeError("concurrency must be a positive integer");
     const owned = await options.store.openOwner({ ownerId: createId("owner"), leaseMs: OWNER_LEASE_MS });
-    const runtime = new _AgentRuntime({ ...options, configs, concurrency }, owned, new RuntimeBootstrapRegistry());
+    const extensions = new RuntimeExtensionLifetime({ host });
+    const runtime = new _AgentRuntime({ ...options, configs, concurrency, host }, owned, new RuntimeBootstrapRegistry(extensions));
     try {
       await runtime.resources.ensureCoreResources();
       await options.bootstrap?.(runtime.resources);
@@ -6164,6 +6594,20 @@ var AgentRuntime = class _AgentRuntime {
       throw error;
     }
   }
+  async handleRunEnd(runId, agentId, outcome) {
+    if (this.startedRuns.has(runId)) {
+      this.startedRuns.delete(runId);
+      try {
+        await this.resources.extensionRunner.emitRunEnd({
+          runId,
+          agentId,
+          outcome
+        });
+      } catch {
+      }
+    }
+    this.resources.extensionRunner.dropRunState(runId);
+  }
   async loadAgents(input) {
     this.assertOpen();
     return this.resources.loadAgents(input);
@@ -6374,6 +6818,14 @@ var AgentRuntime = class _AgentRuntime {
     });
     return { caughtUp: subscription.caughtUp.promise, done: subscription.done.promise, stop: () => controller.abort() };
   }
+  listCapabilities() {
+    this.assertOpen();
+    return this.resources.extensionRunner.getCapabilities();
+  }
+  onCapabilitiesChanged(listener) {
+    this.assertOpen();
+    return this.resources.extensionRunner.onCapabilitiesChanged(listener);
+  }
   async close() {
     if (this.closed) return;
     this.closed = true;
@@ -6417,6 +6869,11 @@ var AgentRuntime = class _AgentRuntime {
     const active = this.executions.get(runId);
     if (active) this.transientEvents.clear(runId, active.executionId);
     active?.controller.abort();
+    if (this.startedRuns.has(runId)) {
+      await this.handleRunEnd(runId, snapshot.agentId, { id: createId("out"), status: "cancelled", message: reason ?? "Agent run stopped." });
+    } else {
+      this.resources.extensionRunner.dropRunState(runId);
+    }
     return boundaryFromSnapshot(await this.owned.snapshotRun(runId));
   }
   async pump() {
@@ -6528,6 +6985,19 @@ var AgentRuntime = class _AgentRuntime {
       const controller = new AbortController();
       this.executions.set(run.id, { controller, executionId });
       if (this.cancellationRequested.has(run.id)) controller.abort();
+      if (!this.startedRuns.has(run.id)) {
+        this.startedRuns.add(run.id);
+        const turn = typeof run.input === "object" && run.input !== null && !Array.isArray(run.input) ? run.input : {};
+        try {
+          await this.resources.extensionRunner.emitRunStart({
+            runId: run.id,
+            agentId: run.agentId,
+            metadata: run.metadata ?? {},
+            turn
+          });
+        } catch {
+        }
+      }
       const assembly = assembleRegisteredExtensions(config, this.resources.extensionRunner, {
         toolArchiveDir: this.archiveDirFor(run.agentId)
       });
@@ -6754,6 +7224,11 @@ var AgentRuntime = class _AgentRuntime {
           ...output && hasVisibleAssistantText(output) ? { output } : {}
         });
         this.transientEvents.clear(run.id, claim.execution.executionId);
+        await this.handleRunEnd(run.id, run.agentId, {
+          id: createId("out"),
+          status: "cancelled",
+          message: reason
+        });
         return;
       }
       if (result.type === "input_required") {
@@ -6789,33 +7264,53 @@ var AgentRuntime = class _AgentRuntime {
         const output = latestAssistant(run, result.messages, executionContext.messages.length);
         await this.owned.commitOutcome({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, outcome: durableOutcome(result.outcome), ...output ? { output } : {} });
         this.transientEvents.clear(run.id, claim.execution.executionId, true);
+        await this.handleRunEnd(run.id, run.agentId, result.outcome);
         return;
       }
       const failure = { code: "execution_failed", message: result.error instanceof Error ? result.error.message : "Execution failed." };
       await this.owned.commitOutcome({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, failure });
       this.transientEvents.clear(run.id, claim.execution.executionId);
+      await this.handleRunEnd(run.id, run.agentId, {
+        id: createId("out"),
+        status: "failed",
+        message: failure.message,
+        error: failure
+      });
     } catch (error) {
       if (!claim && error instanceof RuntimeError && ["run_state_conflict", "runtime_ownership_lost", "run_not_found"].includes(error.code)) return;
       if (claim) {
         if (this.cancellationRequested.has(run.id)) {
+          const reason = this.cancellationReasons.get(run.id) ?? "Agent run stopped.";
           await this.owned.cancelRun({
             runId: run.id,
             expectedRevision: executionRevision,
-            reason: this.cancellationReasons.get(run.id) ?? "Agent run stopped."
+            reason
           }).catch(() => void 0);
+          await this.handleRunEnd(run.id, run.agentId, {
+            id: createId("out"),
+            status: "cancelled",
+            message: reason
+          });
           return;
         }
+        const failureMessage = error instanceof Error ? error.message : "Execution failed.";
         await this.owned.commitOutcome({
           runId: run.id,
           execution: claim.execution,
           expectedRevision: executionRevision,
-          failure: { code: "execution_failed", message: error instanceof Error ? error.message : "Execution failed." }
+          failure: { code: "execution_failed", message: failureMessage }
         }).catch(async (commitError) => {
           await this.owned.cancelRun({
             runId: run.id,
             reason: commitError instanceof Error ? commitError.message : "Run failure could not be committed."
           }).catch(() => void 0);
         });
+        await this.handleRunEnd(run.id, run.agentId, {
+          id: createId("out"),
+          status: "failed",
+          message: failureMessage,
+          error: { code: "execution_failed", message: failureMessage }
+        });
         return;
       }
       throw error;
@@ -6838,6 +7333,8 @@ var AgentRuntime = class _AgentRuntime {
     return { result: batch.results[0], revision: batch.revision };
   }
   async executeToolBatch(input) {
+    const scope = resolveScopeFromMetadata(input.run.metadata);
+    const turn = typeof input.run.input === "object" && input.run.input !== null && !Array.isArray(input.run.input) ? input.run.input : {};
     const checkpoint = input.driver?.checkpoint();
     const isSuspensionResume = checkpoint && typeof checkpoint === "object" && checkpoint.kind === "tool_call_suspension";
     const suspension = isSuspensionResume ? checkpoint : void 0;
@@ -6864,6 +7361,8 @@ var AgentRuntime = class _AgentRuntime {
           ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
           ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
           toolCallId,
+          scope,
+          turn,
           interaction: createRunInteractionDriver({
             currentPhase: "default",
             attempt: 0,
@@ -6951,6 +7450,8 @@ var AgentRuntime = class _AgentRuntime {
             ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
             ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
             toolCallId,
+            scope,
+            turn,
             interaction: createToolInteractionDriver(input.driver, {
               toolCallId,
               toolCallIds,
@@ -7105,6 +7606,8 @@ var AgentRuntime = class _AgentRuntime {
         ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
         ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
         toolCallId,
+        scope,
+        turn,
         interaction: createToolInteractionDriver(input.driver, {
           toolCallId,
           ...suspension?.toolCallIds === void 0 ? {} : { toolCallIds: suspension.toolCallIds },
@@ -7618,9 +8121,83 @@ var InMemoryStore = class _InMemoryStore {
   eventSequence = 0;
   retentionFloor = 1;
   contextCompactions = /* @__PURE__ */ new Map();
+  recorder;
+  runReceiptKeys = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.incarnation = options.incarnation ?? createId("store");
   }
+  setChangeRecorder(recorder) {
+    this.recorder = recorder;
+  }
+  touchAgent(agent) {
+    this.recorder?.onAgentUpsert(agent);
+  }
+  touchRun(run) {
+    this.recorder?.onRunUpsert(run);
+  }
+  storeMessage(message) {
+    this.messages.set(message.id, message);
+    this.recorder?.onMessageInsert(message);
+  }
+  storeToolCall(toolCall) {
+    this.toolCalls.set(toolCall.id, toolCall);
+    this.recorder?.onToolCallUpsert(toolCall);
+  }
+  appendEvent(event) {
+    this.events.push(event);
+    this.recorder?.onEventAppend(event);
+  }
+  inferRunIdForReceipt(key, payload) {
+    const parts = key.split(":");
+    const prefix = parts[0];
+    if (["queued_failure", "phase_entered", "input_required", "interaction_answer", "outcome", "cancel"].includes(prefix) && parts[1]) {
+      return parts[1];
+    }
+    const match = payload.match(/^\[\s*"([^"]+)"/);
+    if (match && match[1]) {
+      const candidate = match[1];
+      if (this.runs.has(candidate) || candidate.startsWith("run_") || candidate.startsWith("run-")) {
+        return candidate;
+      }
+    }
+    return void 0;
+  }
+  dropRunOperationReceipts(runId) {
+    const keys = this.runReceiptKeys.get(runId);
+    if (keys && keys.size > 0) {
+      for (const key of keys) {
+        this.operationReceipts.delete(key);
+        this.recorder?.onOperationReceiptDelete(key);
+      }
+      this.runReceiptKeys.delete(runId);
+    }
+    for (const [key] of this.operationReceipts.entries()) {
+      if (key.includes(`:${runId}:`) || key.endsWith(`:${runId}`) || key.startsWith(`phase_output:${runId}`) || key.startsWith(`tool_reserve_batch:${runId}`)) {
+        this.operationReceipts.delete(key);
+        this.recorder?.onOperationReceiptDelete(key);
+      }
+    }
+  }
+  compactTerminalReceipts() {
+    let count = 0;
+    for (const [key, receipt] of [...this.operationReceipts.entries()]) {
+      const runId = this.inferRunIdForReceipt(key, receipt.payload);
+      if (runId) {
+        const run = this.runs.get(runId);
+        if (!run || ["completed", "failed", "cancelled"].includes(run.state)) {
+          this.operationReceipts.delete(key);
+          const keys = this.runReceiptKeys.get(runId);
+          if (keys) {
+            keys.delete(key);
+            if (keys.size === 0) this.runReceiptKeys.delete(runId);
+          }
+          this.recorder?.onOperationReceiptDelete(key);
+          count += 1;
+        }
+      }
+    }
+    return count;
+  }
   static fromState(state) {
     const store = new _InMemoryStore({ incarnation: state.incarnation });
     for (const agent of state.agents) store.agents.set(agent.id, clone(agent));
@@ -7638,6 +8215,7 @@ var InMemoryStore = class _InMemoryStore {
         clonedRun.updatedAt = createTimestamp();
         store.runs.set(clonedRun.id, clonedRun);
         store.appendTransition(clonedRun, "input_required", "cancelled", { reason: clonedRun.cancellationReason });
+        store.dropRunOperationReceipts(clonedRun.id);
       } else {
         store.runs.set(clonedRun.id, clonedRun);
       }
@@ -7646,7 +8224,18 @@ var InMemoryStore = class _InMemoryStore {
     for (const toolCall of state.toolCalls ?? []) store.toolCalls.set(toolCall.id, clone(toolCall));
     store.events.push(...clone(state.events));
     for (const [key, receipt] of state.idempotency) store.idempotency.set(key, clone(receipt));
-    for (const [key, receipt] of state.operationReceipts) store.operationReceipts.set(key, clone(receipt));
+    for (const [key, receipt] of state.operationReceipts) {
+      store.operationReceipts.set(key, clone(receipt));
+      const runId = store.inferRunIdForReceipt(key, receipt.payload);
+      if (runId) {
+        let keys = store.runReceiptKeys.get(runId);
+        if (!keys) {
+          keys = /* @__PURE__ */ new Set();
+          store.runReceiptKeys.set(runId, keys);
+        }
+        keys.add(key);
+      }
+    }
     for (const [agentId, messages] of state.historySeeds ?? []) store.historySeeds.set(agentId, clone(messages));
     for (const [consumerId, cursor] of state.consumerCheckpoints ?? []) store.consumerCheckpoints.set(consumerId, cursor);
     for (const [agentId, sequence] of state.nextAgentSequence) store.nextAgentSequence.set(agentId, sequence);
@@ -7679,6 +8268,16 @@ var InMemoryStore = class _InMemoryStore {
       contextCompactions: [...this.contextCompactions.entries()]
     });
   }
+  exportMetadata() {
+    return {
+      incarnation: this.incarnation,
+      eventSequence: this.eventSequence,
+      nextAgentSequence: [...this.nextAgentSequence.entries()],
+      nextReadySequence: [...this.nextReadySequence.entries()],
+      historySeeds: [...this.historySeeds.entries()],
+      contextCompactions: [...this.contextCompactions.entries()]
+    };
+  }
   attachOwner(lease) {
     this.owner = clone(lease);
     this.ownerEpoch = Math.max(this.ownerEpoch, lease.epoch);
@@ -7701,6 +8300,7 @@ var InMemoryStore = class _InMemoryStore {
       run.revision += 1;
       run.updatedAt = createTimestamp();
       this.appendTransition(run, "running", "failed", { failure });
+      this.dropRunOperationReceipts(run.id);
     }
   }
   async openOwner(input) {
@@ -7718,6 +8318,7 @@ var InMemoryStore = class _InMemoryStore {
     }
     if (this.owner) this.interruptOwner(this.owner.epoch);
     this.dropSettledClaimReceipts();
+    this.compactTerminalReceipts();
     this.ownerEpoch += 1;
     this.owner = {
       ownerId: input.ownerId,
@@ -7764,6 +8365,7 @@ var InMemoryStore = class _InMemoryStore {
       updatedAt: timestamp
     };
     this.agents.set(agent.id, agent);
+    this.touchAgent(agent);
     if (input.historySeed && input.historySeed.length > 0) this.historySeeds.set(agent.id, materializeHistorySeed(agent.id, input.historySeed));
     this.nextAgentSequence.set(agent.id, 0);
     this.nextReadySequence.set(agent.id, 0);
@@ -7777,6 +8379,7 @@ var InMemoryStore = class _InMemoryStore {
     if (configToken !== void 0) agent.currentConfigToken = configToken;
     if (configIdentity !== void 0) agent.currentConfigIdentity = configIdentity;
     agent.updatedAt = createTimestamp();
+    this.touchAgent(agent);
     return clone(agent);
   }
   updateAgentConfigToken(lease, input) {
@@ -7789,6 +8392,7 @@ var InMemoryStore = class _InMemoryStore {
     agent.currentConfigToken = input.token;
     if (input.configIdentity !== void 0) agent.currentConfigIdentity = input.configIdentity;
     agent.updatedAt = createTimestamp();
+    this.touchAgent(agent);
     this.writeReceipt(scope, payload, agent);
     return clone(agent);
   }
@@ -7810,24 +8414,48 @@ var InMemoryStore = class _InMemoryStore {
     }
     const runIds = new Set(runs.map((run) => run.id));
     this.agents.delete(agent.id);
+    this.recorder?.onAgentDelete(agent.id);
     this.nextAgentSequence.delete(agent.id);
     this.nextReadySequence.delete(agent.id);
     this.historySeeds.delete(agent.id);
-    for (const run of runs) this.runs.delete(run.id);
+    for (const run of runs) {
+      this.runs.delete(run.id);
+      this.runReceiptKeys.delete(run.id);
+      this.recorder?.onRunDelete(run.id);
+    }
     for (const [messageId, message] of this.messages) {
-      if (runIds.has(message.runId)) this.messages.delete(messageId);
+      if (runIds.has(message.runId)) {
+        this.messages.delete(messageId);
+        this.recorder?.onMessageDelete(messageId);
+      }
     }
     for (const [toolCallId, toolCall] of this.toolCalls) {
-      if (runIds.has(toolCall.runId)) this.toolCalls.delete(toolCallId);
+      if (runIds.has(toolCall.runId)) {
+        this.toolCalls.delete(toolCallId);
+        this.recorder?.onToolCallDelete(toolCallId);
+      }
     }
+    const deletedEventIds = [];
     for (let index = this.events.length - 1; index >= 0; index -= 1) {
-      if (this.events[index].agentId === agent.id) this.events.splice(index, 1);
+      if (this.events[index].agentId === agent.id) {
+        deletedEventIds.push(this.events[index].id);
+        this.events.splice(index, 1);
+      }
+    }
+    if (deletedEventIds.length > 0) {
+      this.recorder?.onEventsTruncate(deletedEventIds);
     }
     for (const [key] of this.idempotency) {
-      if (key.includes(String(agent.id)) || [...runIds].some((runId) => key.includes(String(runId)))) this.idempotency.delete(key);
+      if (key.includes(String(agent.id)) || [...runIds].some((runId) => key.includes(String(runId)))) {
+        this.idempotency.delete(key);
+        this.recorder?.onIdempotencyDelete(key);
+      }
     }
     for (const [key] of this.operationReceipts) {
-      if (key.includes(String(agent.id)) || [...runIds].some((runId) => key.includes(String(runId)))) this.operationReceipts.delete(key);
+      if (key.includes(String(agent.id)) || [...runIds].some((runId) => key.includes(String(runId)))) {
+        this.operationReceipts.delete(key);
+        this.recorder?.onOperationReceiptDelete(key);
+      }
     }
   }
   reviseMessage(lease, input) {
@@ -7935,14 +8563,19 @@ var InMemoryStore = class _InMemoryStore {
         run.revision += 1;
         run.updatedAt = timestamp;
         this.appendTransition(run, previousState, "cancelled", { reason: run.cancellationReason });
+        this.dropRunOperationReceipts(run.id);
       } else {
         run.revision += 1;
         run.updatedAt = timestamp;
+        this.touchRun(run);
       }
     }
     for (const [messageId, message] of this.messages) {
       if (!affectedRunSet.has(message.runId)) continue;
-      if (message.runId !== original.runId || message.sequenceWithinRun > original.sequenceWithinRun) this.messages.delete(messageId);
+      if (message.runId !== original.runId || message.sequenceWithinRun > original.sequenceWithinRun) {
+        this.messages.delete(messageId);
+        this.recorder?.onMessageDelete(messageId);
+      }
     }
     if (isSeedMessage) {
       const targetIndex = seed.findIndex(({ id }) => id === original.id);
@@ -7956,10 +8589,11 @@ var InMemoryStore = class _InMemoryStore {
       sequenceWithinRun: 0,
       createdAt: timestamp
     };
-    this.messages.set(revisedMessage.id, revisedMessage);
+    this.storeMessage(revisedMessage);
     this.runs.set(replacementRun.id, replacementRun);
+    this.touchRun(replacementRun);
     this.appendTransition(replacementRun, null, "queued");
-    this.events.push({
+    this.appendEvent({
       ...this.baseEvent(replacementRun),
       kind: "message_revised",
       message: revisedMessage,
@@ -7975,7 +8609,7 @@ var InMemoryStore = class _InMemoryStore {
       affectedToolCallIds: affectedTools.map((toolCall) => toolCall.id),
       ...effectDigest === void 0 ? {} : { effectDigest }
     };
-    this.writeOperationReceipt(operationKey, operationPayload, result);
+    this.writeOperationReceipt(operationKey, operationPayload, result, replacementRun.id);
     return clone(result);
   }
   commitInteractionRecord(run, interaction, status, answer, reply) {
@@ -7997,7 +8631,7 @@ var InMemoryStore = class _InMemoryStore {
       sequenceWithinRun: this.nextMessageSequence(run.id),
       createdAt: now
     };
-    this.messages.set(record.id, record);
+    this.storeMessage(record);
     this.appendMessage(run, record);
     return record;
   }
@@ -8046,12 +8680,13 @@ var InMemoryStore = class _InMemoryStore {
         sequenceWithinRun: this.nextMessageSequence(waitingRun.id),
         createdAt: now
       };
-      this.messages.set(message.id, message);
+      this.storeMessage(message);
       this.appendMessage(waitingRun, message);
       waitingRun.readySequence = this.nextReady(waitingRun.agentId);
       waitingRun.state = "queued";
       waitingRun.revision += 1;
       waitingRun.updatedAt = now;
+      this.touchRun(waitingRun);
       this.appendTransition(waitingRun, "input_required", "queued");
       this.writeReceipt(scope, payload, waitingRun);
       return clone(waitingRun);
@@ -8073,6 +8708,7 @@ var InMemoryStore = class _InMemoryStore {
       updatedAt: timestamp
     };
     this.runs.set(run.id, run);
+    this.touchRun(run);
     this.appendTransition(run, null, "queued");
     this.writeReceipt(scope, payload, run);
     return clone(run);
@@ -8115,7 +8751,7 @@ var InMemoryStore = class _InMemoryStore {
         sequenceWithinRun: this.nextMessageSequence(run.id),
         createdAt: createTimestamp()
       };
-      this.messages.set(message.id, message);
+      this.storeMessage(message);
       committedMessages.push(message);
     }
     const execution = {
@@ -8127,10 +8763,11 @@ var InMemoryStore = class _InMemoryStore {
     run.execution = execution;
     run.revision += 1;
     run.updatedAt = createTimestamp();
+    this.touchRun(run);
     for (const message of committedMessages) this.appendMessage(run, message);
     this.appendTransition(run, "queued", "running");
     const result = { run: clone(run), execution: clone(execution), history: this.activeHistory(run.agentId, run.agentSequence) };
-    this.writeOperationReceipt(operationKey, operationPayload, result);
+    this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
   }
   failQueuedRun(lease, input) {
@@ -8146,9 +8783,11 @@ var InMemoryStore = class _InMemoryStore {
     run.failure = clone(input.failure);
     run.revision += 1;
     run.updatedAt = createTimestamp();
+    this.touchRun(run);
     this.appendTransition(run, "queued", "failed", { failure: input.failure });
+    this.dropRunOperationReceipts(run.id);
     const result = clone(run);
-    this.writeOperationReceipt(operationKey, operationPayload, result);
+    this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
   }
   commitPhaseEntered(lease, input) {
@@ -8164,10 +8803,11 @@ var InMemoryStore = class _InMemoryStore {
     run.currentPhaseId = input.phaseId;
     run.revision += 1;
     run.updatedAt = createTimestamp();
+    this.touchRun(run);
     const visit2 = this.events.filter((event) => event.runId === run.id && event.kind === "phase_entered").length + 1;
-    this.events.push(this.baseEvent(run, { kind: "phase_entered", executionId: input.execution.executionId, phaseId: input.phaseId, visit: visit2 }));
+    this.appendEvent(this.baseEvent(run, { kind: "phase_entered", executionId: input.execution.executionId, phaseId: input.phaseId, visit: visit2 }));
     const result = clone(run);
-    this.writeOperationReceipt(operationKey, operationPayload, result);
+    this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
   }
   /** Commit a parallel Phase's reply while its Run is still running. */
@@ -8188,12 +8828,13 @@ var InMemoryStore = class _InMemoryStore {
       role: "assistant",
       sequenceWithinRun: this.nextMessageSequence(run.id)
     };
-    this.messages.set(message.id, message);
+    this.storeMessage(message);
     run.revision += 1;
     run.updatedAt = createTimestamp();
+    this.touchRun(run);
     this.appendMessage(run, message);
     const result = clone(run);
-    this.writeOperationReceipt(operationKey, operationPayload, result);
+    this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
   }
   commitInputRequired(lease, input) {
@@ -8215,7 +8856,7 @@ var InMemoryStore = class _InMemoryStore {
         ...clone(input.prompt),
         sequenceWithinRun: this.nextMessageSequence(run.id)
       };
-      this.messages.set(prompt.id, prompt);
+      this.storeMessage(prompt);
     }
     run.state = "input_required";
     run.checkpoint = clone(input.checkpoint);
@@ -8230,12 +8871,13 @@ var InMemoryStore = class _InMemoryStore {
     delete run.execution;
     run.revision += 1;
     run.updatedAt = createTimestamp();
+    this.touchRun(run);
     if (prompt) {
       this.appendMessage(run, prompt);
     }
     this.appendTransition(run, "running", "input_required", { prompt, interactions, answers: run.interactionAnswers ?? {} });
     const result = clone(run);
-    this.writeOperationReceipt(operationKey, operationPayload, result);
+    this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
   }
   answerInteraction(lease, input) {
@@ -8283,8 +8925,9 @@ var InMemoryStore = class _InMemoryStore {
       run.state = "queued";
       this.appendTransition(run, "input_required", "queued");
     }
+    this.touchRun(run);
     const result = clone(run);
-    this.writeOperationReceipt(operationKey, operationPayload, result);
+    this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
   }
   reserveToolCall(lease, input) {
@@ -8358,17 +9001,18 @@ var InMemoryStore = class _InMemoryStore {
       sequenceWithinRun: this.nextMessageSequence(run.id),
       createdAt: timestamp
     };
-    for (const toolCall of toolCalls) this.toolCalls.set(toolCall.id, toolCall);
-    this.messages.set(requestMessage.id, requestMessage);
+    for (const toolCall of toolCalls) this.storeToolCall(toolCall);
+    this.storeMessage(requestMessage);
     run.revision += 1;
     run.updatedAt = timestamp;
+    this.touchRun(run);
     this.appendMessage(run, requestMessage);
     for (const toolCall of toolCalls) this.appendToolTransition(run, { from: null, to: "pending" }, toolCall);
     const result = {
       run: clone(run),
       toolCalls: toolCalls.map((toolCall) => clone(toolCall))
     };
-    this.writeOperationReceipt(operationKey, operationPayload, result);
+    this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
   }
   startToolCall(lease, input) {
@@ -8383,13 +9027,14 @@ var InMemoryStore = class _InMemoryStore {
     if (toolCall.state !== "pending") throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
     toolCall.state = "running";
     toolCall.executionId = input.execution.executionId;
-    toolCall.executionId = input.execution.executionId;
     toolCall.updatedAt = createTimestamp();
+    this.storeToolCall(toolCall);
     run.revision += 1;
     run.updatedAt = toolCall.updatedAt;
+    this.touchRun(run);
     this.appendToolTransition(run, { from: "pending", to: "running" }, toolCall);
     const result = { run: clone(run), toolCall: clone(toolCall) };
-    this.writeOperationReceipt(operationKey, operationPayload, result);
+    this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
   }
   suspendToolCall(lease, input) {
@@ -8406,11 +9051,13 @@ var InMemoryStore = class _InMemoryStore {
     }
     toolCall.state = "pending";
     toolCall.updatedAt = createTimestamp();
+    this.storeToolCall(toolCall);
     run.revision += 1;
     run.updatedAt = toolCall.updatedAt;
+    this.touchRun(run);
     this.appendToolTransition(run, { from: "running", to: "pending" }, toolCall);
     const result = { run: clone(run), toolCall: clone(toolCall) };
-    this.writeOperationReceipt(operationKey, operationPayload, result);
+    this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
   }
   commitToolResult(lease, input) {
@@ -8442,15 +9089,17 @@ var InMemoryStore = class _InMemoryStore {
       sequenceWithinRun: this.nextMessageSequence(run.id),
       createdAt: createTimestamp()
     };
-    this.messages.set(message.id, message);
+    this.storeMessage(message);
     toolCall.state = input.state;
     toolCall.result = durableResult;
     toolCall.resultMessageId = resultMessageId;
     if (input.state === "indeterminate") toolCall.reason = input.reason;
     else delete toolCall.reason;
     toolCall.updatedAt = message.createdAt;
+    this.storeToolCall(toolCall);
     run.revision += 1;
     run.updatedAt = message.createdAt;
+    this.touchRun(run);
     this.appendToolTransition(run, { from, to: input.state }, toolCall);
     this.appendMessage(run, message);
     if (input.state === "indeterminate") {
@@ -8471,10 +9120,12 @@ var InMemoryStore = class _InMemoryStore {
       delete run.execution;
       run.revision += 1;
       run.updatedAt = createTimestamp();
+      this.touchRun(run);
       this.appendTransition(run, "running", "failed", { failure });
+      this.dropRunOperationReceipts(run.id);
     }
     const result = { run: clone(run), toolCall: clone(toolCall) };
-    this.writeOperationReceipt(operationKey, operationPayload, result);
+    this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
   }
   commitOutcome(lease, input) {
@@ -8492,7 +9143,7 @@ var InMemoryStore = class _InMemoryStore {
     if (nextState === "failed" && !input.failure) throw new TypeError("failed Run requires a failure");
     const output = input.output ? { ...clone(input.output), sequenceWithinRun: this.nextMessageSequence(run.id) } : void 0;
     if (output) {
-      this.messages.set(output.id, output);
+      this.storeMessage(output);
       this.appendMessage(run, output);
     }
     run.state = nextState;
@@ -8504,9 +9155,10 @@ var InMemoryStore = class _InMemoryStore {
     delete run.interactionAnswers;
     run.revision += 1;
     run.updatedAt = createTimestamp();
+    this.touchRun(run);
     this.appendTransition(run, "running", nextState, { outcome: input.outcome, failure: input.failure, output });
+    this.dropRunOperationReceipts(run.id);
     const result = clone(run);
-    this.writeOperationReceipt(operationKey, operationPayload, result);
     return result;
   }
   cancelRun(lease, input) {
@@ -8526,7 +9178,6 @@ var InMemoryStore = class _InMemoryStore {
     }
     if (["completed", "failed", "cancelled"].includes(run.state)) {
       const result2 = clone(run);
-      if (input.expectedRevision !== void 0) this.writeOperationReceipt(operationKey, operationPayload, result2);
       return result2;
     }
     const from = run.state;
@@ -8541,7 +9192,7 @@ var InMemoryStore = class _InMemoryStore {
     for (const toolCall of activeToolCalls) this.interruptToolCall(run, toolCall, input.reason ?? "The Run was cancelled.");
     if (input.output && (typeof input.output.content === "string" ? input.output.content.length > 0 : input.output.content.length > 0)) {
       const output = { ...clone(input.output), sequenceWithinRun: this.nextMessageSequence(run.id) };
-      this.messages.set(output.id, output);
+      this.storeMessage(output);
       this.appendMessage(run, output);
     }
     if (run.openInteractions && run.openInteractions.length > 0) {
@@ -8564,9 +9215,10 @@ var InMemoryStore = class _InMemoryStore {
       delete run.interactionAnswers;
       run.revision += 1;
       run.updatedAt = createTimestamp();
+      this.touchRun(run);
       this.appendTransition(run, from, "failed", { failure });
+      this.dropRunOperationReceipts(run.id);
       const result2 = clone(run);
-      if (input.expectedRevision !== void 0) this.writeOperationReceipt(operationKey, operationPayload, result2);
       return result2;
     }
     run.state = "cancelled";
@@ -8577,9 +9229,10 @@ var InMemoryStore = class _InMemoryStore {
     delete run.interactionAnswers;
     run.revision += 1;
     run.updatedAt = createTimestamp();
+    this.touchRun(run);
     this.appendTransition(run, from, "cancelled", { reason: input.reason });
+    this.dropRunOperationReceipts(run.id);
     const result = clone(run);
-    if (input.expectedRevision !== void 0) this.writeOperationReceipt(operationKey, operationPayload, result);
     return result;
   }
   snapshotRun(lease, runId) {
@@ -8660,6 +9313,7 @@ var InMemoryStore = class _InMemoryStore {
     const previous = this.consumerCheckpoints.get(input.consumerId);
     if (previous !== void 0 && next <= this.parseCursor(previous)) return;
     this.consumerCheckpoints.set(input.consumerId, input.cursor);
+    this.recorder?.onConsumerCheckpointUpsert(input.consumerId, input.cursor);
   }
   compact(lease, input = {}) {
     this.assertOwner(lease);
@@ -8693,11 +9347,15 @@ var InMemoryStore = class _InMemoryStore {
     }
     const deletedEvents = deleteThrough >= this.retentionFloor ? this.events.filter((event) => this.parseCursor(event.cursor) <= deleteThrough) : [];
     if (deleteThrough >= this.retentionFloor) {
+      const deletedEventIds = this.events.filter((event) => this.parseCursor(event.cursor) <= deleteThrough).map((event) => event.id);
       this.events.splice(0, this.events.length, ...this.events.filter((event) => this.parseCursor(event.cursor) > deleteThrough));
       this.retentionFloor = deleteThrough + 1;
+      this.recorder?.onRetentionFloorChange(this.retentionFloor);
+      this.recorder?.onEventsTruncate(deletedEventIds);
       for (const [consumerId, cursor] of this.consumerCheckpoints) {
         if (this.parseCursor(cursor) < this.retentionFloor - 1) {
           this.consumerCheckpoints.delete(consumerId);
+          this.recorder?.onConsumerCheckpointDelete(consumerId);
         }
       }
     }
@@ -8706,11 +9364,21 @@ var InMemoryStore = class _InMemoryStore {
     const deletedRunIds = deletableRuns.map((run) => run.id);
     const deletedRunSet = new Set(deletedRunIds);
     const deletedTools = [...this.toolCalls.values()].filter((tool) => deletedRunSet.has(tool.runId));
-    for (const runId of deletedRunIds) this.runs.delete(runId);
+    for (const runId of deletedRunIds) {
+      this.runs.delete(runId);
+      this.runReceiptKeys.delete(runId);
+      this.recorder?.onRunDelete(runId);
+    }
     for (const [messageId, message] of this.messages) {
-      if (deletedRunSet.has(message.runId)) this.messages.delete(messageId);
+      if (deletedRunSet.has(message.runId)) {
+        this.messages.delete(messageId);
+        this.recorder?.onMessageDelete(messageId);
+      }
+    }
+    for (const tool of deletedTools) {
+      this.toolCalls.delete(tool.id);
+      this.recorder?.onToolCallDelete(tool.id);
     }
-    for (const tool of deletedTools) this.toolCalls.delete(tool.id);
     return {
       deletedRunIds,
       deletedToolCallIds: deletedTools.map((tool) => tool.id),
@@ -8732,7 +9400,10 @@ var InMemoryStore = class _InMemoryStore {
     return receipt.result;
   }
   writeReceipt(scope, payload, result) {
-    this.idempotency.set(encodeIdempotencyScope(this.incarnation, scope), { payload, result: clone(result) });
+    const key = encodeIdempotencyScope(this.incarnation, scope);
+    const receipt = { payload, result: clone(result) };
+    this.idempotency.set(key, receipt);
+    this.recorder?.onIdempotencyUpsert(key, receipt);
   }
   replayOperation(key, payload) {
     const receipt = this.operationReceipts.get(key);
@@ -8740,8 +9411,19 @@ var InMemoryStore = class _InMemoryStore {
     if (receipt.payload !== payload) throw new Error(`Idempotency payload conflict for ${key}.`);
     return receipt.result;
   }
-  writeOperationReceipt(key, payload, result) {
-    this.operationReceipts.set(key, { payload, result: clone(result) });
+  writeOperationReceipt(key, payload, result, runId) {
+    const receipt = { payload, result: clone(result) };
+    this.operationReceipts.set(key, receipt);
+    const resolvedRunId = runId ?? this.inferRunIdForReceipt(key, payload);
+    if (resolvedRunId) {
+      let keys = this.runReceiptKeys.get(resolvedRunId);
+      if (!keys) {
+        keys = /* @__PURE__ */ new Set();
+        this.runReceiptKeys.set(resolvedRunId, keys);
+      }
+      keys.add(key);
+    }
+    this.recorder?.onOperationReceiptUpsert(key, receipt);
   }
   /**
    * A Claim receipt exists for idempotent replay of one live Execution Attempt
@@ -8749,7 +9431,11 @@ var InMemoryStore = class _InMemoryStore {
    * one history snapshot per Agent instead of one per Attempt.
    */
   dropClaimReceipt(execution) {
-    if (execution) this.operationReceipts.delete(`claim:${execution.executionId}`);
+    if (execution) {
+      const key = `claim:${execution.executionId}`;
+      this.operationReceipts.delete(key);
+      this.recorder?.onOperationReceiptDelete(key);
+    }
   }
   /**
    * A new owner fences the Execution Attempts of the previous one, so no Claim
@@ -8765,6 +9451,7 @@ var InMemoryStore = class _InMemoryStore {
     for (const key of [...this.operationReceipts.keys()]) {
       if (key.startsWith("claim:") && !liveExecutions.has(key.slice("claim:".length))) {
         this.operationReceipts.delete(key);
+        this.recorder?.onOperationReceiptDelete(key);
       }
     }
   }
@@ -8803,14 +9490,16 @@ var InMemoryStore = class _InMemoryStore {
     };
     const from = toolCall.state;
     const to = from === "running" ? "indeterminate" : "failed";
-    this.messages.set(message.id, message);
+    this.storeMessage(message);
     toolCall.state = to;
     toolCall.result = durableResult;
     toolCall.resultMessageId = message.id;
     if (to === "indeterminate") toolCall.reason = reason;
     toolCall.updatedAt = message.createdAt;
+    this.storeToolCall(toolCall);
     run.revision += 1;
     run.updatedAt = message.createdAt;
+    this.touchRun(run);
     this.appendToolTransition(run, { from, to }, toolCall);
     this.appendMessage(run, message);
   }
@@ -8911,6 +9600,7 @@ ${record.summary}`,
     if (existing?.id === record.id) return clone(existing);
     const next = clone(record);
     this.contextCompactions.set(record.agentId, next);
+    this.recorder?.onContextCompactionUpsert(record.agentId, next);
     return clone(next);
   }
   activeHistory(agentId, beforeSequence) {
@@ -8920,7 +9610,7 @@ ${record.summary}`,
     ].map((message) => ({ ...message, messageRevision: message.messageRevision ?? 0 })));
   }
   appendMessage(run, message) {
-    this.events.push(this.baseEvent(run, {
+    this.appendEvent(this.baseEvent(run, {
       kind: "message_committed",
       message
     }));
@@ -8936,13 +9626,14 @@ ${record.summary}`,
       ...to === "failed" && options?.failure ? { failure: options.failure } : {},
       ...to === "cancelled" && options?.reason ? { reason: options.reason } : {}
     };
-    this.events.push(transition);
+    this.touchRun(run);
+    this.appendEvent(transition);
   }
   appendToolTransition(run, transition, toolCall) {
-    this.events.push(this.baseEvent(run, {
+    this.appendEvent(this.baseEvent(run, {
       kind: "tool_state_changed",
       transition,
-      toolCall
+      toolCall: clone(toolCall)
     }));
   }
   baseEvent(run, extra) {
@@ -9318,6 +10009,94 @@ var CURRENT_SCHEMA_SQL = `
   CREATE INDEX runs_active_idx ON runs (agent_id, state, agent_sequence);
   CREATE INDEX run_events_sequence_idx ON run_events (sequence);
 `;
+var ChangeTracker = class {
+  upsertedAgents = /* @__PURE__ */ new Map();
+  deletedAgentIds = /* @__PURE__ */ new Set();
+  upsertedRuns = /* @__PURE__ */ new Map();
+  deletedRunIds = /* @__PURE__ */ new Set();
+  insertedMessages = /* @__PURE__ */ new Map();
+  deletedMessageIds = /* @__PURE__ */ new Set();
+  upsertedToolCalls = /* @__PURE__ */ new Map();
+  deletedToolCallIds = /* @__PURE__ */ new Set();
+  appendedEvents = [];
+  truncatedEventIds = /* @__PURE__ */ new Set();
+  upsertedIdempotency = /* @__PURE__ */ new Map();
+  deletedIdempotencyScopes = /* @__PURE__ */ new Set();
+  upsertedOperationReceipts = /* @__PURE__ */ new Map();
+  deletedOperationReceiptKeys = /* @__PURE__ */ new Set();
+  upsertedConsumerCheckpoints = /* @__PURE__ */ new Map();
+  deletedConsumerCheckpoints = /* @__PURE__ */ new Set();
+  upsertedContextCompactions = /* @__PURE__ */ new Map();
+  retentionFloorChanged;
+  onAgentUpsert(agent) {
+    this.deletedAgentIds.delete(agent.id);
+    this.upsertedAgents.set(agent.id, agent);
+  }
+  onAgentDelete(agentId) {
+    this.upsertedAgents.delete(agentId);
+    this.deletedAgentIds.add(agentId);
+  }
+  onRunUpsert(run) {
+    this.deletedRunIds.delete(run.id);
+    this.upsertedRuns.set(run.id, run);
+  }
+  onRunDelete(runId) {
+    this.upsertedRuns.delete(runId);
+    this.deletedRunIds.add(runId);
+  }
+  onMessageInsert(message) {
+    this.deletedMessageIds.delete(message.id);
+    this.insertedMessages.set(message.id, message);
+  }
+  onMessageDelete(messageId) {
+    this.insertedMessages.delete(messageId);
+    this.deletedMessageIds.add(messageId);
+  }
+  onToolCallUpsert(toolCall) {
+    this.deletedToolCallIds.delete(toolCall.id);
+    this.upsertedToolCalls.set(toolCall.id, toolCall);
+  }
+  onToolCallDelete(toolCallId) {
+    this.upsertedToolCalls.delete(toolCallId);
+    this.deletedToolCallIds.add(toolCallId);
+  }
+  onEventAppend(event) {
+    this.appendedEvents.push(event);
+  }
+  onEventsTruncate(deletedEventIds) {
+    for (const id of deletedEventIds) this.truncatedEventIds.add(id);
+  }
+  onIdempotencyUpsert(scope, receipt) {
+    this.deletedIdempotencyScopes.delete(scope);
+    this.upsertedIdempotency.set(scope, receipt);
+  }
+  onIdempotencyDelete(scope) {
+    this.upsertedIdempotency.delete(scope);
+    this.deletedIdempotencyScopes.add(scope);
+  }
+  onOperationReceiptUpsert(key, receipt) {
+    this.deletedOperationReceiptKeys.delete(key);
+    this.upsertedOperationReceipts.set(key, receipt);
+  }
+  onOperationReceiptDelete(key) {
+    this.upsertedOperationReceipts.delete(key);
+    this.deletedOperationReceiptKeys.add(key);
+  }
+  onConsumerCheckpointUpsert(consumerId, cursor) {
+    this.deletedConsumerCheckpoints.delete(consumerId);
+    this.upsertedConsumerCheckpoints.set(consumerId, cursor);
+  }
+  onConsumerCheckpointDelete(consumerId) {
+    this.upsertedConsumerCheckpoints.delete(consumerId);
+    this.deletedConsumerCheckpoints.add(consumerId);
+  }
+  onContextCompactionUpsert(agentId, record) {
+    this.upsertedContextCompactions.set(agentId, record);
+  }
+  onRetentionFloorChange(floor) {
+    this.retentionFloorChanged = floor;
+  }
+};
 var SqliteStore = class {
   database;
   archiveRoot;
@@ -9326,6 +10105,25 @@ var SqliteStore = class {
   mirroredAgents = /* @__PURE__ */ new Set();
   closed = false;
   configured = false;
+  cachedMemory;
+  cachedOwner;
+  isLegacyState = false;
+  stmtUpsertAgent;
+  stmtDeleteAgent;
+  stmtUpsertRun;
+  stmtDeleteRun;
+  stmtInsertMessage;
+  stmtDeleteMessage;
+  stmtUpsertToolCall;
+  stmtDeleteToolCall;
+  stmtInsertEvent;
+  stmtDeleteEvent;
+  stmtUpsertIdempotency;
+  stmtDeleteIdempotency;
+  stmtUpsertCheckpoint;
+  stmtDeleteCheckpoint;
+  stmtUpdateMeta;
+  stmtUpdateState;
   constructor(filename = ":memory:") {
     this.database = new Database(filename, { create: true, readwrite: true, strict: true });
     this.archiveRoot = filename === ":memory:" ? join6(tmpdir2(), `rowan-context-archives-${crypto.randomUUID()}`) : join6(dirname7(resolve8(filename)), "context-archives");
@@ -9346,7 +10144,26 @@ var SqliteStore = class {
         }
         const replay = ownerLease(row);
         this.writeOwner({ ...row, expires_at: now + input.leaseMs });
-        return { ...replay, expiresAt: new Date(now + input.leaseMs).toISOString() };
+        const newLease2 = { ...replay, expiresAt: new Date(now + input.leaseMs).toISOString() };
+        if (!this.cachedMemory || this.cachedOwner?.epoch !== replay.epoch) {
+          const state2 = this.readState();
+          const memory2 = InMemoryStore.fromState(state2);
+          memory2.attachOwner(newLease2);
+          const tracker2 = new ChangeTracker();
+          memory2.setChangeRecorder(tracker2);
+          try {
+            memory2.dropSettledClaimReceipts();
+            memory2.compactTerminalReceipts();
+          } finally {
+            memory2.setChangeRecorder(void 0);
+          }
+          this.ensureTableBackedStorage(memory2, tracker2, this.isLegacyState);
+          this.cachedMemory = memory2;
+        } else {
+          this.cachedMemory.attachOwner(newLease2);
+        }
+        this.cachedOwner = newLease2;
+        return newLease2;
       }
       const state = this.readState();
       const memory = InMemoryStore.fromState(state);
@@ -9365,22 +10182,42 @@ var SqliteStore = class {
         released_epoch: row.released_epoch
       };
       this.writeOwner(next);
-      memory.dropSettledClaimReceipts();
-      this.persistState(memory.exportState());
-      return {
+      const newLease = {
         ownerId: input.ownerId,
         token,
         epoch,
         expiresAt: new Date(now + input.leaseMs).toISOString()
       };
+      memory.attachOwner(newLease);
+      const tracker = new ChangeTracker();
+      memory.setChangeRecorder(tracker);
+      try {
+        memory.dropSettledClaimReceipts();
+        memory.compactTerminalReceipts();
+      } finally {
+        memory.setChangeRecorder(void 0);
+      }
+      this.ensureTableBackedStorage(memory, tracker, this.isLegacyState);
+      this.cachedMemory = memory;
+      this.cachedOwner = newLease;
+      return newLease;
     });
     return new SqliteOwnedStore(this, lease);
   }
   close() {
     if (this.closed) return;
     this.closed = true;
+    this.cachedMemory = void 0;
+    this.cachedOwner = void 0;
     this.database.close();
   }
+  exportState() {
+    if (this.cachedMemory) {
+      return this.cachedMemory.exportState();
+    }
+    const state = this.readState();
+    return InMemoryStore.fromState(state).exportState();
+  }
   /** Filesystem location owned by this Store for one Agent's readable archive. */
   contextArchiveDir(agentId) {
     return join6(this.archiveRoot, String(agentId));
@@ -9465,31 +10302,7 @@ var SqliteStore = class {
   }
   async listEvents(lease, input = {}) {
     this.assertOpen();
-    return this.readTransaction(() => {
-      this.requireMatchingOwner(lease, true);
-      const retentionRow = this.database.query(
-        "SELECT value FROM runtime_meta WHERE key = ?"
-      ).get(RETENTION_FLOOR_KEY);
-      const retentionFloor = Math.max(1, Number(retentionRow?.value ?? "1"));
-      const after = input.after ? parseEventCursor(lease, input.after) : retentionFloor - 1;
-      if (input.after && after < retentionFloor - 1) {
-        throw new RuntimeError("invalid_cursor", { cursorType: "event", reason: "expired" });
-      }
-      if (input.after) {
-        const latest = this.database.query(
-          "SELECT max(sequence) AS sequence FROM run_events"
-        ).get();
-        const waterline = latest.sequence ?? 0;
-        if (after > waterline) {
-          throw new RuntimeError("invalid_cursor", { cursorType: "event", reason: "beyond_waterline" });
-        }
-        if (after === waterline) return [];
-      }
-      const rows = this.database.query(
-        "SELECT payload_json FROM run_events ORDER BY sequence"
-      ).all();
-      return rows.map((row) => JSON.parse(row.payload_json)).filter((event) => parseEventCursor(lease, event.cursor) > after);
-    });
+    return this.read(lease, (memory) => memory.listEvents(lease, input));
   }
   async openConsumer(lease, consumerId) {
     return this.invoke(lease, (store, current) => store.openConsumer(current, consumerId), false);
@@ -9513,7 +10326,12 @@ var SqliteStore = class {
       const row = this.requireMatchingOwner(lease, false);
       const expiresAt = Date.now() + leaseMs;
       this.writeOwner({ ...row, expires_at: expiresAt });
-      return { ...lease, expiresAt: new Date(expiresAt).toISOString() };
+      const nextLease = { ...lease, expiresAt: new Date(expiresAt).toISOString() };
+      if (this.cachedOwner && this.cachedOwner.token === lease.token) {
+        this.cachedOwner = nextLease;
+        this.cachedMemory?.attachOwner(nextLease);
+      }
+      return nextLease;
     });
   }
   async sealAndReleaseOwner(lease) {
@@ -9524,27 +10342,75 @@ var SqliteStore = class {
       if (row.owner_id !== lease.ownerId || row.owner_token !== lease.token || row.epoch !== lease.epoch) {
         throw ownershipLost2(lease, row);
       }
-      const memory = InMemoryStore.fromState(this.readState());
-      memory.attachOwner(lease);
-      memory.interruptOwner(lease.epoch, "The Runtime owner was sealed.");
-      this.persistState(memory.exportState());
+      if (!this.cachedMemory || this.cachedOwner?.epoch !== lease.epoch) {
+        this.cachedMemory = InMemoryStore.fromState(this.readState());
+        this.cachedOwner = lease;
+      }
+      const tracker = new ChangeTracker();
+      this.cachedMemory.setChangeRecorder(tracker);
+      try {
+        this.cachedMemory.attachOwner(lease);
+        this.cachedMemory.interruptOwner(lease.epoch, "The Runtime owner was sealed.");
+      } finally {
+        this.cachedMemory.setChangeRecorder(void 0);
+      }
+      this.persistChanges(tracker, this.cachedMemory);
+      this.mirrorChanges(tracker);
       this.writeOwner({ ...row, owner_id: null, owner_token: null, expires_at: null, released_epoch: lease.epoch });
+      this.cachedMemory = void 0;
+      this.cachedOwner = void 0;
     });
   }
-  invoke(lease, operation, persist = true) {
+  read(lease, operation) {
+    this.assertOpen();
+    this.requireMatchingOwner(lease, true);
+    if (!this.cachedMemory || this.cachedOwner?.epoch !== lease.epoch) {
+      this.cachedMemory = InMemoryStore.fromState(this.readState());
+      this.cachedMemory.attachOwner(lease);
+      this.cachedOwner = lease;
+    } else {
+      this.cachedMemory.attachOwner(lease);
+    }
+    return operation(this.cachedMemory);
+  }
+  write(lease, operation) {
     this.assertOpen();
     return this.immediateTransaction(() => {
       this.requireMatchingOwner(lease, true);
-      const memory = InMemoryStore.fromState(this.readState());
-      memory.attachOwner(lease);
-      const result = operation(memory, lease);
-      if (persist) {
-        this.requireMatchingOwner(lease, true);
-        this.persistState(memory.exportState());
+      if (!this.cachedMemory || this.cachedOwner?.epoch !== lease.epoch) {
+        this.cachedMemory = InMemoryStore.fromState(this.readState());
+        this.cachedMemory.attachOwner(lease);
+        this.cachedOwner = lease;
+      } else {
+        this.cachedMemory.attachOwner(lease);
+      }
+      const tracker = new ChangeTracker();
+      this.cachedMemory.setChangeRecorder(tracker);
+      let result;
+      try {
+        result = operation(this.cachedMemory);
+      } catch (error) {
+        this.cachedMemory.setChangeRecorder(void 0);
+        this.cachedMemory = void 0;
+        throw error;
+      }
+      this.cachedMemory.setChangeRecorder(void 0);
+      try {
+        this.persistChanges(tracker, this.cachedMemory);
+        this.mirrorChanges(tracker);
+      } catch (error) {
+        this.cachedMemory = void 0;
+        throw error;
       }
       return result;
     });
   }
+  invoke(lease, operation, persist = true) {
+    if (persist) {
+      return this.write(lease, (memory) => operation(memory, lease));
+    }
+    return this.read(lease, (memory) => operation(memory, lease));
+  }
   ensureSchema() {
     const catalog = this.catalog();
     if (catalog.length > 0 && !this.isCurrentSchema(catalog)) {
@@ -9561,7 +10427,7 @@ var SqliteStore = class {
         this.database.run("INSERT INTO runtime_meta (key, value) VALUES (?, ?)", [RETENTION_FLOOR_KEY, "1"]);
         const state = new InMemoryStore();
         this.database.run("INSERT INTO runtime_owner (singleton, epoch) VALUES (?, ?)", [STATE_ROW, 0]);
-        this.database.run("INSERT INTO runtime_state (singleton, state_json) VALUES (?, ?)", [STATE_ROW, JSON.stringify(state.exportState())]);
+        this.database.run("INSERT INTO runtime_state (singleton, state_json) VALUES (?, ?)", [STATE_ROW, JSON.stringify(state.exportMetadata())]);
       });
       return;
     }
@@ -9600,13 +10466,267 @@ var SqliteStore = class {
   readState() {
     const row = this.database.query("SELECT state_json FROM runtime_state WHERE singleton = ?").get(STATE_ROW);
     if (!row) throw new RuntimeError("store_unavailable", { operation: "read_state", retryable: false, reason: "runtime_state row is missing" });
-    return JSON.parse(row.state_json);
+    const parsed = JSON.parse(row.state_json);
+    if (parsed.agents && Array.isArray(parsed.agents)) {
+      this.isLegacyState = true;
+      return parsed;
+    }
+    this.isLegacyState = false;
+    return this.loadTableBackedState(parsed);
+  }
+  loadTableBackedState(metadata) {
+    const agentRows = this.database.query(
+      "SELECT id, metadata_json, config_token, config_identity, created_at, activated_at, updated_at FROM agents ORDER BY created_at"
+    ).all();
+    const agents = agentRows.map((row) => ({
+      id: row.id,
+      ...row.metadata_json ? { metadata: JSON.parse(row.metadata_json) } : {},
+      ...row.config_token ? { currentConfigToken: row.config_token } : {},
+      ...row.config_identity ? { currentConfigIdentity: row.config_identity } : {},
+      createdAt: row.created_at,
+      ...row.activated_at ? { activatedAt: row.activated_at } : {},
+      updatedAt: row.updated_at
+    }));
+    const runRows = this.database.query("SELECT payload_json FROM runs").all();
+    const runs = runRows.map((r) => JSON.parse(r.payload_json));
+    const messageRows = this.database.query("SELECT payload_json FROM messages ORDER BY run_id, sequence_within_run").all();
+    const messages = messageRows.map((m) => JSON.parse(m.payload_json));
+    const toolRows = this.database.query("SELECT payload_json FROM tool_calls").all();
+    const toolCalls = toolRows.map((t) => JSON.parse(t.payload_json));
+    const eventRows = this.database.query("SELECT payload_json FROM run_events ORDER BY sequence").all();
+    const events = eventRows.map((e) => JSON.parse(e.payload_json));
+    const idempotencyRows = this.database.query("SELECT scope, payload_json, result_json FROM idempotency").all();
+    const idempotency = [];
+    const operationReceipts = [];
+    for (const row of idempotencyRows) {
+      const receipt = { payload: row.payload_json, result: JSON.parse(row.result_json) };
+      if (row.scope.startsWith("operation:")) {
+        operationReceipts.push([row.scope.slice("operation:".length), receipt]);
+      } else {
+        idempotency.push([row.scope, receipt]);
+      }
+    }
+    const cpRows = this.database.query("SELECT consumer_id, sequence FROM consumer_checkpoints").all();
+    const consumerCheckpoints = cpRows.map((r) => [r.consumer_id, `${metadata.incarnation}:${r.sequence}`]);
+    const retentionRow = this.database.query("SELECT value FROM runtime_meta WHERE key = ?").get(RETENTION_FLOOR_KEY);
+    const retentionFloor = Math.max(1, Number(retentionRow?.value ?? metadata.retentionFloor ?? "1"));
+    return {
+      incarnation: metadata.incarnation,
+      agents,
+      runs,
+      messages,
+      toolCalls,
+      events,
+      idempotency,
+      operationReceipts,
+      historySeeds: metadata.historySeeds ?? [],
+      consumerCheckpoints,
+      retentionFloor,
+      nextAgentSequence: metadata.nextAgentSequence ?? [],
+      nextReadySequence: metadata.nextReadySequence ?? [],
+      eventSequence: metadata.eventSequence ?? 0,
+      contextCompactions: metadata.contextCompactions ?? []
+    };
+  }
+  ensureTableBackedStorage(memory, tracker, isLegacy) {
+    if (isLegacy) {
+      this.writeFullStateToTables(memory);
+      this.isLegacyState = false;
+    } else {
+      this.persistChanges(tracker, memory);
+      this.mirrorChanges(tracker);
+    }
+  }
+  getStmtUpsertAgent() {
+    return this.stmtUpsertAgent ??= this.database.prepare(
+      `INSERT INTO agents (id, metadata_json, config_token, config_identity, created_at, activated_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         metadata_json = excluded.metadata_json,
+         config_token = excluded.config_token,
+         config_identity = excluded.config_identity,
+         activated_at = excluded.activated_at,
+         updated_at = excluded.updated_at`
+    );
+  }
+  getStmtDeleteAgent() {
+    return this.stmtDeleteAgent ??= this.database.prepare("DELETE FROM agents WHERE id = ?");
+  }
+  getStmtUpsertRun() {
+    return this.stmtUpsertRun ??= this.database.prepare(
+      `INSERT INTO runs (id, agent_id, agent_sequence, state, revision, payload_json, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         state = excluded.state,
+         revision = excluded.revision,
+         payload_json = excluded.payload_json,
+         updated_at = excluded.updated_at`
+    );
+  }
+  getStmtDeleteRun() {
+    return this.stmtDeleteRun ??= this.database.prepare("DELETE FROM runs WHERE id = ?");
+  }
+  getStmtInsertMessage() {
+    return this.stmtInsertMessage ??= this.database.prepare(
+      `INSERT INTO messages (id, run_id, sequence_within_run, payload_json, created_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET payload_json = excluded.payload_json`
+    );
+  }
+  getStmtDeleteMessage() {
+    return this.stmtDeleteMessage ??= this.database.prepare("DELETE FROM messages WHERE id = ?");
   }
-  writeState(state) {
-    this.database.run("UPDATE runtime_state SET state_json = ? WHERE singleton = ?", [JSON.stringify(state), STATE_ROW]);
+  getStmtUpsertToolCall() {
+    return this.stmtUpsertToolCall ??= this.database.prepare(
+      `INSERT INTO tool_calls (id, run_id, execution_id, state, payload_json)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET state = excluded.state, payload_json = excluded.payload_json`
+    );
   }
-  persistState(state) {
-    this.writeState(state);
+  getStmtDeleteToolCall() {
+    return this.stmtDeleteToolCall ??= this.database.prepare("DELETE FROM tool_calls WHERE id = ?");
+  }
+  getStmtInsertEvent() {
+    return this.stmtInsertEvent ??= this.database.prepare(
+      "INSERT INTO run_events (id, run_id, payload_json, created_at) VALUES (?, ?, ?, ?)"
+    );
+  }
+  getStmtDeleteEvent() {
+    return this.stmtDeleteEvent ??= this.database.prepare("DELETE FROM run_events WHERE id = ?");
+  }
+  getStmtUpsertIdempotency() {
+    return this.stmtUpsertIdempotency ??= this.database.prepare(
+      `INSERT INTO idempotency (scope, payload_json, result_json)
+       VALUES (?, ?, ?)
+       ON CONFLICT(scope) DO UPDATE SET payload_json = excluded.payload_json, result_json = excluded.result_json`
+    );
+  }
+  getStmtDeleteIdempotency() {
+    return this.stmtDeleteIdempotency ??= this.database.prepare("DELETE FROM idempotency WHERE scope = ?");
+  }
+  getStmtUpsertCheckpoint() {
+    return this.stmtUpsertCheckpoint ??= this.database.prepare(
+      `INSERT INTO consumer_checkpoints (consumer_id, sequence, event_id, updated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(consumer_id) DO UPDATE SET sequence = excluded.sequence, updated_at = excluded.updated_at`
+    );
+  }
+  getStmtDeleteCheckpoint() {
+    return this.stmtDeleteCheckpoint ??= this.database.prepare("DELETE FROM consumer_checkpoints WHERE consumer_id = ?");
+  }
+  getStmtUpdateMeta() {
+    return this.stmtUpdateMeta ??= this.database.prepare(
+      "INSERT INTO runtime_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+    );
+  }
+  getStmtUpdateState() {
+    return this.stmtUpdateState ??= this.database.prepare(
+      "UPDATE runtime_state SET state_json = ? WHERE singleton = ?"
+    );
+  }
+  persistChanges(tracker, memory) {
+    for (const agent of tracker.upsertedAgents.values()) {
+      this.getStmtUpsertAgent().run(
+        agent.id,
+        agent.metadata === void 0 ? null : JSON.stringify(agent.metadata),
+        agent.currentConfigToken ?? null,
+        agent.currentConfigIdentity ?? null,
+        agent.createdAt,
+        agent.activatedAt ?? null,
+        agent.updatedAt
+      );
+    }
+    for (const agentId of tracker.deletedAgentIds) {
+      this.getStmtDeleteAgent().run(agentId);
+    }
+    for (const run of tracker.upsertedRuns.values()) {
+      this.getStmtUpsertRun().run(
+        run.id,
+        run.agentId,
+        run.agentSequence,
+        run.state,
+        run.revision,
+        JSON.stringify(run),
+        run.createdAt,
+        run.updatedAt
+      );
+    }
+    for (const runId of tracker.deletedRunIds) {
+      this.getStmtDeleteRun().run(runId);
+    }
+    for (const message of tracker.insertedMessages.values()) {
+      this.getStmtInsertMessage().run(
+        message.id,
+        message.runId,
+        message.sequenceWithinRun,
+        JSON.stringify(message),
+        message.createdAt
+      );
+    }
+    for (const messageId of tracker.deletedMessageIds) {
+      this.getStmtDeleteMessage().run(messageId);
+    }
+    for (const toolCall of tracker.upsertedToolCalls.values()) {
+      this.getStmtUpsertToolCall().run(
+        toolCall.id,
+        toolCall.runId,
+        toolCall.executionId,
+        toolCall.state,
+        JSON.stringify(toolCall)
+      );
+    }
+    for (const toolCallId of tracker.deletedToolCallIds) {
+      this.getStmtDeleteToolCall().run(toolCallId);
+    }
+    for (const event of tracker.appendedEvents) {
+      this.getStmtInsertEvent().run(
+        event.id,
+        event.runId,
+        JSON.stringify(event),
+        event.createdAt
+      );
+    }
+    for (const eventId of tracker.truncatedEventIds) {
+      this.getStmtDeleteEvent().run(eventId);
+    }
+    for (const [scope, receipt] of tracker.upsertedIdempotency) {
+      this.getStmtUpsertIdempotency().run(
+        scope,
+        receipt.payload,
+        JSON.stringify(receipt.result)
+      );
+    }
+    for (const scope of tracker.deletedIdempotencyScopes) {
+      this.getStmtDeleteIdempotency().run(scope);
+    }
+    for (const [key, receipt] of tracker.upsertedOperationReceipts) {
+      this.getStmtUpsertIdempotency().run(
+        `operation:${key}`,
+        receipt.payload,
+        JSON.stringify(receipt.result)
+      );
+    }
+    for (const key of tracker.deletedOperationReceiptKeys) {
+      this.getStmtDeleteIdempotency().run(`operation:${key}`);
+    }
+    for (const [consumerId, cursor] of tracker.upsertedConsumerCheckpoints) {
+      this.getStmtUpsertCheckpoint().run(
+        consumerId,
+        Number(String(cursor).split(":").at(-1)),
+        null,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+    }
+    for (const consumerId of tracker.deletedConsumerCheckpoints) {
+      this.getStmtDeleteCheckpoint().run(consumerId);
+    }
+    if (tracker.retentionFloorChanged !== void 0) {
+      this.getStmtUpdateMeta().run(RETENTION_FLOOR_KEY, String(tracker.retentionFloorChanged));
+    }
+    this.getStmtUpdateState().run(JSON.stringify(memory.exportMetadata()), STATE_ROW);
+  }
+  writeFullStateToTables(memory) {
+    const state = memory.exportState();
     this.database.run(
       "INSERT INTO runtime_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
       [RETENTION_FLOOR_KEY, String(Math.max(1, state.retentionFloor ?? 1))]
@@ -9615,57 +10735,149 @@ var SqliteStore = class {
       this.database.run(`DELETE FROM ${table}`);
     }
     for (const agent of state.agents) {
-      this.database.run(
-        "INSERT INTO agents (id, metadata_json, config_token, config_identity, created_at, activated_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
-        [agent.id, agent.metadata === void 0 ? null : JSON.stringify(agent.metadata), agent.currentConfigToken ?? null, agent.currentConfigIdentity ?? null, agent.createdAt, agent.activatedAt ?? null, agent.updatedAt]
+      this.getStmtUpsertAgent().run(
+        agent.id,
+        agent.metadata === void 0 ? null : JSON.stringify(agent.metadata),
+        agent.currentConfigToken ?? null,
+        agent.currentConfigIdentity ?? null,
+        agent.createdAt,
+        agent.activatedAt ?? null,
+        agent.updatedAt
       );
     }
     for (const run of state.runs) {
-      this.database.run(
-        "INSERT INTO runs (id, agent_id, agent_sequence, state, revision, payload_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-        [run.id, run.agentId, run.agentSequence, run.state, run.revision, JSON.stringify(run), run.createdAt, run.updatedAt]
+      this.getStmtUpsertRun().run(
+        run.id,
+        run.agentId,
+        run.agentSequence,
+        run.state,
+        run.revision,
+        JSON.stringify(run),
+        run.createdAt,
+        run.updatedAt
       );
     }
     for (const message of state.messages) {
-      this.database.run(
-        "INSERT INTO messages (id, run_id, sequence_within_run, payload_json, created_at) VALUES (?, ?, ?, ?, ?)",
-        [message.id, message.runId, message.sequenceWithinRun, JSON.stringify(message), message.createdAt]
+      this.getStmtInsertMessage().run(
+        message.id,
+        message.runId,
+        message.sequenceWithinRun,
+        JSON.stringify(message),
+        message.createdAt
       );
     }
     for (const toolCall of state.toolCalls) {
-      this.database.run(
-        "INSERT INTO tool_calls (id, run_id, execution_id, state, payload_json) VALUES (?, ?, ?, ?, ?)",
-        [toolCall.id, toolCall.runId, toolCall.executionId, toolCall.state, JSON.stringify(toolCall)]
+      this.getStmtUpsertToolCall().run(
+        toolCall.id,
+        toolCall.runId,
+        toolCall.executionId,
+        toolCall.state,
+        JSON.stringify(toolCall)
       );
     }
     for (const event of state.events) {
-      this.database.run(
-        "INSERT INTO run_events (id, run_id, payload_json, created_at) VALUES (?, ?, ?, ?)",
-        [event.id, event.runId, JSON.stringify(event), event.createdAt]
+      this.getStmtInsertEvent().run(
+        event.id,
+        event.runId,
+        JSON.stringify(event),
+        event.createdAt
       );
     }
     for (const [scope, receipt] of state.idempotency) {
-      this.database.run(
-        "INSERT INTO idempotency (scope, payload_json, result_json) VALUES (?, ?, ?)",
-        [scope, receipt.payload, JSON.stringify(receipt.result)]
+      this.getStmtUpsertIdempotency().run(
+        scope,
+        receipt.payload,
+        JSON.stringify(receipt.result)
       );
     }
     for (const [scope, receipt] of state.operationReceipts) {
-      this.database.run(
-        "INSERT INTO idempotency (scope, payload_json, result_json) VALUES (?, ?, ?)",
-        [`operation:${scope}`, receipt.payload, JSON.stringify(receipt.result)]
+      this.getStmtUpsertIdempotency().run(
+        `operation:${scope}`,
+        receipt.payload,
+        JSON.stringify(receipt.result)
       );
     }
     for (const [consumerId, cursor] of state.consumerCheckpoints ?? []) {
-      this.database.run(
-        "INSERT INTO consumer_checkpoints (consumer_id, sequence, event_id, updated_at) VALUES (?, ?, ?, ?)",
-        [consumerId, Number(String(cursor).split(":").at(-1)), null, (/* @__PURE__ */ new Date()).toISOString()]
+      this.getStmtUpsertCheckpoint().run(
+        consumerId,
+        Number(String(cursor).split(":").at(-1)),
+        null,
+        (/* @__PURE__ */ new Date()).toISOString()
       );
     }
-    this.mirrorState(state);
+    this.getStmtUpdateState().run(JSON.stringify(memory.exportMetadata()), STATE_ROW);
+    this.mirrorInitialState(state);
+  }
+  mirrorChanges(tracker) {
+    for (const agentId of tracker.deletedAgentIds) {
+      const idStr = String(agentId);
+      rmSync(join6(this.archiveRoot, idStr), { recursive: true, force: true });
+      this.mirroredEventIds.delete(idStr);
+      this.mirroredCompactionIds.delete(idStr);
+      this.mirroredAgents.delete(idStr);
+    }
+    for (const agent of tracker.upsertedAgents.values()) {
+      const idStr = String(agent.id);
+      this.mirroredAgents.add(idStr);
+      const archiveDir = join6(this.archiveRoot, idStr);
+      const toolDir = join6(archiveDir, "tool-results");
+      mkdirSync(toolDir, { recursive: true, mode: 448 });
+      chmodSync(archiveDir, 448);
+      chmodSync(toolDir, 448);
+    }
+    if (tracker.appendedEvents.length > 0) {
+      mkdirSync(this.archiveRoot, { recursive: true, mode: 448 });
+      chmodSync(this.archiveRoot, 448);
+      const eventsByAgent = /* @__PURE__ */ new Map();
+      for (const event of tracker.appendedEvents) {
+        const agentId = String(event.agentId);
+        let list = eventsByAgent.get(agentId);
+        if (!list) {
+          list = [];
+          eventsByAgent.set(agentId, list);
+        }
+        list.push(event);
+      }
+      for (const [agentId, events] of eventsByAgent) {
+        const archiveDir = join6(this.archiveRoot, agentId);
+        const toolDir = join6(archiveDir, "tool-results");
+        mkdirSync(toolDir, { recursive: true, mode: 448 });
+        chmodSync(archiveDir, 448);
+        chmodSync(toolDir, 448);
+        const sessionPath = join6(archiveDir, "session.jsonl");
+        try {
+          chmodSync(sessionPath, 384);
+        } catch {
+        }
+        const known = this.mirroredEventIds.get(agentId) ?? /* @__PURE__ */ new Set();
+        const newEvents = events.filter((e) => !known.has(String(e.id)));
+        if (newEvents.length > 0) {
+          const lines = newEvents.map((e) => JSON.stringify({ schemaVersion: 1, kind: "rowan_event", event: e }) + "\n").join("");
+          appendFileSync(sessionPath, lines, { encoding: "utf8", mode: 384 });
+          chmodSync(sessionPath, 384);
+          for (const e of newEvents) known.add(String(e.id));
+          this.mirroredEventIds.set(agentId, known);
+        }
+      }
+    }
+    if (tracker.upsertedContextCompactions.size > 0) {
+      for (const [agentId, record] of tracker.upsertedContextCompactions) {
+        const idStr = String(agentId);
+        const archiveDir = join6(this.archiveRoot, idStr);
+        const sessionPath = join6(archiveDir, "session.jsonl");
+        const knownCompactions = this.mirroredCompactionIds.get(idStr) ?? /* @__PURE__ */ new Set();
+        if (!knownCompactions.has(record.id)) {
+          const line = JSON.stringify({ schemaVersion: 1, kind: "context_compacted", record }) + "\n";
+          appendFileSync(sessionPath, line, { encoding: "utf8", mode: 384 });
+          chmodSync(sessionPath, 384);
+          knownCompactions.add(record.id);
+          this.mirroredCompactionIds.set(idStr, knownCompactions);
+        }
+      }
+    }
   }
   /** Append the semantic durable event mirror and remove deleted Agent sidecars. */
-  mirrorState(state) {
+  mirrorInitialState(state) {
     mkdirSync(this.archiveRoot, { recursive: true, mode: 448 });
     chmodSync(this.archiveRoot, 448);
     const currentAgents = new Set(state.agents.map((agent) => String(agent.id)));
@@ -9885,19 +11097,6 @@ function ownerLease(row) {
     expiresAt: new Date(row.expires_at).toISOString()
   };
 }
-function parseEventCursor(lease, cursor) {
-  const value = String(cursor);
-  const separator = value.lastIndexOf(":");
-  const incarnation = separator < 0 ? "" : value.slice(0, separator);
-  const sequence = separator < 0 ? "" : value.slice(separator + 1);
-  const token = String(lease.token);
-  const ownerSuffix = `:${lease.epoch}:${lease.ownerId}`;
-  const expectedIncarnation = token.endsWith(ownerSuffix) ? token.slice(0, -ownerSuffix.length) : "";
-  if (incarnation !== expectedIncarnation || !/^\d+$/.test(sequence)) {
-    throw new RuntimeError("invalid_cursor", { cursorType: "event", reason: "wrong_store" });
-  }
-  return Number(sequence);
-}
 function ownershipLost2(lease, row) {
   return new RuntimeError("runtime_ownership_lost", {
     reason: row.epoch > lease.epoch ? "epoch_advanced" : row.owner_id ? "released" : "released",
@@ -9924,6 +11123,7 @@ export {
   DEFAULT_PHASE_ID,
   ExtensionLifetimeError,
   InMemoryConfigProvider,
+  InMemoryExtensionHost,
   InMemoryStore,
   ResourceRegistry,
   ResourceRegistryError,