@rowan-agent/agent 0.15.3 → 0.15.5

package/dist/index.js

@@ -3264,6 +3264,13 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
     }
   };
 }
+function parallelPhaseReply(produced) {
+  const last = [...produced].reverse().find((message) => message.role === "assistant");
+  if (!last) return void 0;
+  if (typeof last.content === "string") return last.content.trim() ? last : void 0;
+  if (last.content.some((part) => part.type === "tool_use")) return void 0;
+  return last.content.some((part) => part.type === "text" && part.text.trim()) ? last : void 0;
+}
 async function executeParallelPhase(config, state, registry, phase, payload, instruction, context, availablePhases, instanceId, groupId, index, count, sourcePhaseId) {
   const messages = [...context];
   const effectivePayload = preparePhasePayload(phase.input, payload);
@@ -3305,7 +3312,12 @@ async function executeParallelPhase(config, state, registry, phase, payload, ins
   const toolExecutionManager = createToolExecutionManager();
   const execution = createPhaseExecution(config, state, phase, messageManager, toolExecutionManager, registry);
   const runtime = { phase, config, state, execution, messageManager, registry, context: phaseContext };
+  const phaseStart = messages.length;
   let output = await executePhase(runtime);
+  const reply = parallelPhaseReply(messages.slice(phaseStart));
+  if (reply && config.onParallelPhaseOutput) {
+    await config.onParallelPhaseOutput(reply, { mode: "parallel", instanceId, groupId, index, count, sourcePhaseId });
+  }
   if (phaseMsgId) removePhaseMessage(messages, phaseMsgId);
   if (config.afterPhase) {
     const extAfter = await config.afterPhase(phase.name, output);
@@ -3483,6 +3495,7 @@ async function executeOnce(input) {
     afterPhase: input.afterPhase,
     beforePrompt: input.beforePrompt,
     onMessage: input.onMessage,
+    onParallelPhaseOutput: input.onParallelPhaseOutput,
     onMessageDelta: input.onMessageDelta,
     onThinkingDelta: input.onThinkingDelta,
     onOutcome: input.onOutcome,
@@ -4307,6 +4320,10 @@ function renderInteractionText(record) {
   const replyStr = record.reply ?? "";
   return template.replaceAll("{{prompt}}", record.prompt).replaceAll("{{answer}}", answerStr).replaceAll("{{reply}}", replyStr);
 }
+var PARALLEL_PHASE_METADATA_KEY = "parallelPhase";
+function isParallelPhaseOutput(message) {
+  return message.role === "assistant" && message.metadata?.[PARALLEL_PHASE_METADATA_KEY] !== void 0;
+}
 function projectModelContext(input) {
   const toolInteractionTexts = /* @__PURE__ */ new Map();
   for (const message of input.messages) {
@@ -4322,6 +4339,7 @@ function projectModelContext(input) {
   }
   const projectedMessages = [];
   for (const message of input.messages) {
+    if (isParallelPhaseOutput(message)) continue;
     if (message.role === "interaction") {
       if (message.toolCallId !== void 0) {
         continue;
@@ -6613,6 +6631,33 @@ var AgentRuntime = class _AgentRuntime {
             status
           });
         },
+        onParallelPhaseOutput: (message, invocation) => {
+          const task = toolQueue.then(async () => {
+            const active = this.executions.get(run.id);
+            if (this.closed || controller.signal.aborted || active?.executionId !== claim.execution.executionId) return;
+            const projected = projectAssistantMessage(message, run.agentId, run.id, 0);
+            const committed = await this.owned.commitPhaseOutput({
+              runId: run.id,
+              execution: claim.execution,
+              expectedRevision: executionRevision,
+              message: {
+                ...projected,
+                metadata: {
+                  ...projected.metadata,
+                  [PARALLEL_PHASE_METADATA_KEY]: {
+                    groupId: invocation.groupId,
+                    instanceId: invocation.instanceId,
+                    index: invocation.index,
+                    count: invocation.count
+                  }
+                }
+              }
+            });
+            executionRevision = committed.revision;
+          });
+          toolQueue = task.then(() => void 0, () => void 0);
+          return task;
+        },
         onMessageDelta: (event) => {
           const active = this.executions.get(run.id);
           if (this.closed || controller.signal.aborted || active?.executionId !== claim.execution.executionId) return;
@@ -6700,7 +6745,7 @@ var AgentRuntime = class _AgentRuntime {
         }
       }
       if (this.cancellationRequested.has(run.id) || controller.signal.aborted) {
-        const output = latestAssistant(run, result.messages, modelMessages.length, true);
+        const output = latestAssistant(run, result.messages, executionContext.messages.length, true);
         const reason = this.cancellationReasons.get(run.id) ?? "Agent run stopped.";
         await this.owned.cancelRun({
           runId: run.id,
@@ -6723,7 +6768,7 @@ var AgentRuntime = class _AgentRuntime {
         const output = isToolCallInteraction ? void 0 : latestAssistant(
           run,
           result.messages,
-          modelMessages.length
+          executionContext.messages.length
         );
         const prompt = isToolCallInteraction ? void 0 : output ?? (result.interactions[0]?.prompt ? promptMessage(run, result.interactions[0].prompt, result.messages.length) : void 0);
         await this.owned.commitInputRequired({
@@ -6741,7 +6786,7 @@ var AgentRuntime = class _AgentRuntime {
         return;
       }
       if (result.type === "completed") {
-        const output = latestAssistant(run, result.messages, modelMessages.length);
+        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);
         return;
@@ -7573,9 +7618,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));
@@ -7593,6 +7712,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);
       }
@@ -7601,7 +7721,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);
@@ -7634,6 +7765,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);
@@ -7656,6 +7797,7 @@ var InMemoryStore = class _InMemoryStore {
       run.revision += 1;
       run.updatedAt = createTimestamp();
       this.appendTransition(run, "running", "failed", { failure });
+      this.dropRunOperationReceipts(run.id);
     }
   }
   async openOwner(input) {
@@ -7673,6 +7815,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,
@@ -7719,6 +7862,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);
@@ -7732,6 +7876,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) {
@@ -7744,6 +7889,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);
   }
@@ -7765,24 +7911,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) {
@@ -7890,14 +8060,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);
@@ -7911,10 +8086,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,
@@ -7930,7 +8106,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) {
@@ -7952,7 +8128,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;
   }
@@ -8001,12 +8177,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);
@@ -8028,6 +8205,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);
@@ -8070,7 +8248,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 = {
@@ -8082,10 +8260,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) {
@@ -8101,9 +8280,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) {
@@ -8119,10 +8300,38 @@ 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. */
+  commitPhaseOutput(lease, input) {
+    this.assertOwner(lease);
+    const operationKey = `phase_output:${input.message.id}`;
+    const operationPayload = canonicalJson([input.runId, input.execution.executionId, input.expectedRevision, input.message]);
+    const replay = this.replayOperation(operationKey, operationPayload);
+    if (replay) return clone(replay);
+    const run = this.requireRun(input.runId);
+    this.assertExecution(run, input.execution, input.expectedRevision);
+    this.assertState(run, ["running"]);
+    if (this.messages.has(input.message.id)) throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
+    const message = {
+      ...clone(input.message),
+      agentId: run.agentId,
+      runId: run.id,
+      role: "assistant",
+      sequenceWithinRun: this.nextMessageSequence(run.id)
+    };
+    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, run.id);
     return result;
   }
   commitInputRequired(lease, input) {
@@ -8144,7 +8353,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);
@@ -8159,12 +8368,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) {
@@ -8212,8 +8422,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) {
@@ -8287,17 +8498,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) {
@@ -8312,13 +8524,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) {
@@ -8335,11 +8548,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) {
@@ -8371,15 +8586,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") {
@@ -8400,10 +8617,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) {
@@ -8421,7 +8640,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;
@@ -8433,9 +8652,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) {
@@ -8455,7 +8675,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;
@@ -8470,7 +8689,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) {
@@ -8493,9 +8712,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";
@@ -8506,9 +8726,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) {
@@ -8589,6 +8810,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);
@@ -8622,11 +8844,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);
         }
       }
     }
@@ -8635,11 +8861,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),
@@ -8661,7 +8897,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);
@@ -8669,8 +8908,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
@@ -8678,7 +8928,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
@@ -8694,6 +8948,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);
       }
     }
   }
@@ -8732,14 +8987,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);
   }
@@ -8840,6 +9097,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) {
@@ -8849,7 +9107,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
     }));
@@ -8865,13 +9123,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) {
@@ -8944,6 +9203,9 @@ var MemoryOwnedStore = class {
   async commitPhaseEntered(input) {
     return this.store.commitPhaseEntered(this.lease, input);
   }
+  async commitPhaseOutput(input) {
+    return this.store.commitPhaseOutput(this.lease, input);
+  }
   async commitInputRequired(input) {
     return this.store.commitInputRequired(this.lease, input);
   }
@@ -9244,6 +9506,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;
@@ -9252,6 +9602,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");
@@ -9272,7 +9641,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);
@@ -9291,22 +9679,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));
@@ -9347,6 +9755,9 @@ var SqliteStore = class {
   async commitPhaseEntered(lease, input) {
     return this.invoke(lease, (store, current) => store.commitPhaseEntered(current, input));
   }
+  async commitPhaseOutput(lease, input) {
+    return this.invoke(lease, (store, current) => store.commitPhaseOutput(current, input));
+  }
   async commitInputRequired(lease, input) {
     return this.invoke(lease, (store, current) => store.commitInputRequired(current, input));
   }
@@ -9388,31 +9799,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);
@@ -9436,7 +9823,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) {
@@ -9447,27 +9839,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)) {
@@ -9484,7 +9924,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;
     }
@@ -9523,13 +9963,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 = ?");
+  }
+  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`
+    );
+  }
+  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`
+    );
   }
-  writeState(state) {
-    this.database.run("UPDATE runtime_state SET state_json = ? WHERE singleton = ?", [JSON.stringify(state), STATE_ROW]);
+  getStmtDeleteIdempotency() {
+    return this.stmtDeleteIdempotency ??= this.database.prepare("DELETE FROM idempotency WHERE scope = ?");
   }
-  persistState(state) {
-    this.writeState(state);
+  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))]
@@ -9538,57 +10232,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)));
@@ -9740,6 +10526,9 @@ var SqliteOwnedStore = class {
   commitPhaseEntered(input) {
     return this.store.commitPhaseEntered(this.lease, input);
   }
+  commitPhaseOutput(input) {
+    return this.store.commitPhaseOutput(this.lease, input);
+  }
   commitInputRequired(input) {
     return this.store.commitInputRequired(this.lease, input);
   }
@@ -9805,19 +10594,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",