Class MemorySessionStore

packages/runtime/src/__tests__/session-manager.test.ts:17170–17460

}

class MemorySessionStore implements SessionStore {
  private headers = new Map<string, SessionHeader>();
  private messages = new Map<string, StoredMessage[]>();
  private executionBoundaries = new Map<string, ExecutionBoundary>();
  private sandboxBoundaryRequests = new Map<string, SandboxBoundaryRequest>();
  readonly failReadMessagesFor = new Set<string>();
  readonly failNextReadMessagesFor = new Map<string, number>();
  readonly failListTurnsFor = new Set<string>();
  readonly failUpdateHeaderFor = new Set<string>();
  failNextAppendMessage: ((message: StoredMessage) => boolean) | undefined;
  failAfterNextAppendMessage: ((message: StoredMessage) => boolean) | undefined;
  disposeCount = 0;
  nextReadHeaderGate: { started: Gate; release: Gate } | undefined;
  nextGraphOperatorProvisionGate: { started: Gate; release: Gate } | undefined;
  generatedTitleAttempted: Gate | undefined;

  async createSubagent(
    input: CreateSessionInput,
    initialBoundary?: ExecutionBoundary,
  ): Promise<{ header: SessionHeader; created: boolean }> {
    const parent = input.subagentParent;
    const spawn = input.subagentSpawn;
    if (!parent || !input.subagentRuntime || !spawn) {
      throw new Error('Missing child-session metadata');
    }
    const existing = Array.from(this.headers.values()).find((header) => {
      const candidate = header.subagentParent;
      return (
        candidate?.parentSessionId === parent.parentSessionId &&
        candidate.spawnedBy.parentRunId === parent.spawnedBy.parentRunId &&
        candidate.spawnedBy.toolCallId === parent.spawnedBy.toolCallId &&
        candidate.swarm?.swarmId === parent.swarm?.swarmId &&
        candidate.swarm?.itemId === parent.swarm?.itemId
      );
    });
    if (existing) {
      if (
        existing.subagentSpawn?.requestFingerprint !== spawn.requestFingerprint ||
        existing.subagentParent?.spawnedBy.parentTurnId !== parent.spawnedBy.parentTurnId
      ) {
        throw new Error('Child-session spawn identity was reused for different work');
      }
      return { header: existing, created: false };
    }
    return { header: await this.create(input, initialBoundary), created: true };
  }

  async createAgentGraphOperator(
    input: CreateSessionInput,
    request: AgentGraphOperatorProvisionRequest,
    _expectedRevision: number,
    initialBoundary?: ExecutionBoundary,
  ): Promise<{ header: SessionHeader } & AgentGraphOperatorProvisionResult> {
    const gate = this.nextGraphOperatorProvisionGate;
    if (gate) {
      this.nextGraphOperatorProvisionGate = undefined;
      gate.started.release();
      await gate.release.promise;